斗地主AI算法——第十章の被动出牌(4)

最新推荐文章于 2020-09-14 21:30:00 发布
最新推荐文章于 2020-09-14 21:30:00 发布
阅读量5.0k 收藏 8
点赞数 1
CC 4.0 BY-SA版权
分类专栏： C/C++ 游戏算法 文章标签： 斗地主 棋牌算法 算法 ai C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sm9sun/article/details/70853139
本文详细介绍了斗地主游戏中三带一和四带二牌型的算法实现过程，包括如何枚举牌型、评估出牌效果及选择最优策略等内容。

上一章已经说明了单顺的实现方法，双顺、三不带顺牌型实现方法与单牌基本类似。改动的地方除了上一章说的枚举牌类型，出牌时value_nPutCardList的处理，回溯时value_aHandCardList和nHandCardCount的变化等几个方面，还有length设置的变化，因为双顺的length是count的1/2，三顺是1/3。

下面给出完整代码：

//对连类型
	else if (clsGameSituation.uctNowCardGroup.cgType == cgDOUBLE_LINE)
	{
		//剪枝：如果能出去最后一手牌直接出
		CardGroupData SurCardGroupData = ins_SurCardsType(clsHandCardData.value_aHandCardList);
		if (SurCardGroupData.cgType != cgERROR)
		{
			if (SurCardGroupData.cgType == cgDOUBLE_LINE&&SurCardGroupData.nMaxCard>clsGameSituation.uctNowCardGroup.nMaxCard
				&&SurCardGroupData.nCount == clsGameSituation.uctNowCardGroup.nCount)
			{
				Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);
				return;
			}
			else if (SurCardGroupData.cgType == cgBOMB_CARD || SurCardGroupData.cgType == cgKING_CARD)
			{
				Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);
				return;
			}
		}


		//暂存最佳的价值
		HandCardValue BestHandCardValue = get_HandCardValue(clsHandCardData);


		//我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。
		BestHandCardValue.NeedRound += 1;

		//暂存最佳的牌号
		int BestMaxCard = 0;
		//是否出牌的标志
		bool PutCards = false;
		//验证顺子的标志
		int prov = 0;
		//顺子起点
		int start_i = 0;
		//顺子终点
		int end_i = 0;
		//顺子长度
		int length = clsGameSituation.uctNowCardGroup.nCount/2;
		//2与王不参与顺子，从当前已打出的顺子最小牌值+1开始遍历
		for (int i = clsGameSituation.uctNowCardGroup.nMaxCard - length + 2; i < 15; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] > 1)
			{
				prov++;
			}
			else
			{
				prov = 0;
			}
			if (prov >= length)
			{
				end_i = i;
				start_i = i - length + 1;

				for (int j = start_i; j <= end_i; j++)
				{
					clsHandCardData.value_aHandCardList[j] -=2;
				}
				clsHandCardData.nHandCardCount -= clsGameSituation.uctNowCardGroup.nCount;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				for (int j = start_i; j <= end_i; j++)
				{
					clsHandCardData.value_aHandCardList[j] +=2;
				}
				clsHandCardData.nHandCardCount += clsGameSituation.uctNowCardGroup.nCount;

				//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
				{
					BestHandCardValue = tmpHandCardValue;
					BestMaxCard = end_i;
					PutCards = true;
				}

			}
		}

		if (PutCards)
		{
			for (int j = start_i; j <= end_i; j++)
			{
				clsHandCardData.value_nPutCardList.push_back(j);
				clsHandCardData.value_nPutCardList.push_back(j);
			}
			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgDOUBLE_LINE, BestMaxCard, clsGameSituation.uctNowCardGroup.nCount);
			return;
		}

		//-------------------------------------------炸弹-------------------------------------------

		for (int i = 3; i < 16; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] == 4)
			{

				//尝试打出炸弹，估算剩余手牌价值,因为炸弹可以参与顺子，不能因为影响顺子而任意出炸
				clsHandCardData.value_aHandCardList[i] -= 4;
				clsHandCardData.nHandCardCount -= 4;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				clsHandCardData.value_aHandCardList[i] += 4;
				clsHandCardData.nHandCardCount += 4;

				//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7))
					//如果剩余手牌价值为正，证明出去的几率很大， 那么可以用炸获得先手
					|| tmpHandCardValue.SumValue > 0)
				{
					BestHandCardValue = tmpHandCardValue;
					BestMaxCard = i;
					PutCards = true;
				}

			}
		}
		if (PutCards)
		{
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, BestMaxCard, 4);
			return;
		}

		//王炸
		if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)
		{
			//如果剩余手牌价值为正，证明出去的几率很大，那么可以用炸获得先手，王炸20分
			if (BestHandCardValue.SumValue > 20)
			{
				clsHandCardData.value_nPutCardList.push_back(17);
				clsHandCardData.value_nPutCardList.push_back(16);
				clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);
				return;
			}
		}



		//管不上
		clsHandCardData.uctPutCardType = get_GroupData(cgZERO, 0, 0);
		return;

	}
	//三连类型
	else if (clsGameSituation.uctNowCardGroup.cgType == cgTHREE_LINE)
	{
		//剪枝：如果能出去最后一手牌直接出
		CardGroupData SurCardGroupData = ins_SurCardsType(clsHandCardData.value_aHandCardList);
		if (SurCardGroupData.cgType != cgERROR)
		{
			if (SurCardGroupData.cgType == cgTHREE_LINE&&SurCardGroupData.nMaxCard>clsGameSituation.uctNowCardGroup.nMaxCard
				&&SurCardGroupData.nCount == clsGameSituation.uctNowCardGroup.nCount)
			{
				Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);
				return;
			}
			else if (SurCardGroupData.cgType == cgBOMB_CARD || SurCardGroupData.cgType == cgKING_CARD)
			{
				Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);
				return;
			}
		}


		//暂存最佳的价值
		HandCardValue BestHandCardValue = get_HandCardValue(clsHandCardData);


		//我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。
		BestHandCardValue.NeedRound += 1;

		//暂存最佳的牌号
		int BestMaxCard = 0;
		//是否出牌的标志
		bool PutCards = false;
		//验证顺子的标志
		int prov = 0;
		//顺子起点
		int start_i = 0;
		//顺子终点
		int end_i = 0;
		//顺子长度
		int length = clsGameSituation.uctNowCardGroup.nCount / 3;
		//2与王不参与顺子，从当前已打出的顺子最小牌值+1开始遍历
		for (int i = clsGameSituation.uctNowCardGroup.nMaxCard - length + 2; i < 15; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] > 2)
			{
				prov++;
			}
			else
			{
				prov = 0;
			}
			if (prov >= length)
			{
				end_i = i;
				start_i = i - length + 1;

				for (int j = start_i; j <= end_i; j++)
				{
					clsHandCardData.value_aHandCardList[j] -= 3;
				}
				clsHandCardData.nHandCardCount -= clsGameSituation.uctNowCardGroup.nCount;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				for (int j = start_i; j <= end_i; j++)
				{
					clsHandCardData.value_aHandCardList[j] += 3;
				}
				clsHandCardData.nHandCardCount += clsGameSituation.uctNowCardGroup.nCount;

				//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
				{
					BestHandCardValue = tmpHandCardValue;
					BestMaxCard = end_i;
					PutCards = true;
				}

			}
		}

		if (PutCards)
		{
			for (int j = start_i; j <= end_i; j++)
			{
				clsHandCardData.value_nPutCardList.push_back(j);
				clsHandCardData.value_nPutCardList.push_back(j);
				clsHandCardData.value_nPutCardList.push_back(j);
			}
			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgTHREE_LINE, BestMaxCard, clsGameSituation.uctNowCardGroup.nCount);
			return;
		}

		//-------------------------------------------炸弹-------------------------------------------

		for (int i = 3; i < 16; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] == 4)
			{

				//尝试打出炸弹，估算剩余手牌价值,因为炸弹可以参与顺子，不能因为影响顺子而任意出炸
				clsHandCardData.value_aHandCardList[i] -= 4;
				clsHandCardData.nHandCardCount -= 4;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				clsHandCardData.value_aHandCardList[i] += 4;
				clsHandCardData.nHandCardCount += 4;

				//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7))
					//如果剩余手牌价值为正，证明出去的几率很大， 那么可以用炸获得先手
					|| tmpHandCardValue.SumValue > 0)
				{
					BestHandCardValue = tmpHandCardValue;
					BestMaxCard = i;
					PutCards = true;
				}

			}
		}
		if (PutCards)
		{
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, BestMaxCard, 4);
			return;
		}

		//王炸
		if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)
		{
			//如果剩余手牌价值为正，证明出去的几率很大，那么可以用炸获得先手，王炸20分
			if (BestHandCardValue.SumValue > 20)
			{
				clsHandCardData.value_nPutCardList.push_back(17);
				clsHandCardData.value_nPutCardList.push_back(16);
				clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);
				return;
			}
		}



		//管不上
		clsHandCardData.uctPutCardType = get_GroupData(cgZERO, 0, 0);
		return;
	}


接下来我们讲三带一的算法，其实也很简单，无非就是在确定了三牌之后再通过循环枚举出能够返回最佳权值的顺出去的那张牌。


三带一单：

		//暂存最佳的价值
		HandCardValue BestHandCardValue = get_HandCardValue(clsHandCardData);
		//我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。
		BestHandCardValue.NeedRound += 1;
		//暂存最佳的牌号
		int BestMaxCard = 0;
		//顺带出去的牌
		int tmp_1 = 0;
		//是否出牌的标志
		bool PutCards = false;
		//三带一
		for (int i = clsGameSituation.uctNowCardGroup.nMaxCard + 1; i < 16; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] >2)
			{
				for (int j = 3; j < 18; j++)
				{
					//选出一张以上的牌且不是选择三张的那个牌
					if (clsHandCardData.value_aHandCardList[j] > 0 && j != i)
					{
						clsHandCardData.value_aHandCardList[i] -= 3;
						clsHandCardData.value_aHandCardList[j] -= 1;
						clsHandCardData.nHandCardCount -= 4;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						clsHandCardData.value_aHandCardList[i] += 3;
						clsHandCardData.value_aHandCardList[j] += 1;
						clsHandCardData.nHandCardCount += 4;
						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestMaxCard = i;
							tmp_1 = j;
							PutCards = true;
						}
					}
				}
			}
		}
		if (PutCards)
		{
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(tmp_1);
			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgTHREE_TAKE_ONE, BestMaxCard, 4);
			return;
		}

三带一对：

for (int i = clsGameSituation.uctNowCardGroup.nMaxCard + 1; i < 16; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] >2)
			{
				for (int j = 3; j < 16; j++)
				{
					//选出一张以上的牌且不是选择三张的那个牌
					if (clsHandCardData.value_aHandCardList[j] > 1 && j != i)
					{
						clsHandCardData.value_aHandCardList[i] -= 3;
						clsHandCardData.value_aHandCardList[j] -= 2;
						clsHandCardData.nHandCardCount -= 5;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						clsHandCardData.value_aHandCardList[i] += 3;
						clsHandCardData.value_aHandCardList[j] += 2;
						clsHandCardData.nHandCardCount += 5;
						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestMaxCard = i;
							tmp_1 = j;
							PutCards = true;
						}
					}
				}
			}
		}
		if (PutCards)
		{
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(BestMaxCard);
			clsHandCardData.value_nPutCardList.push_back(tmp_1);
			clsHandCardData.value_nPutCardList.push_back(tmp_1);
			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgTHREE_TAKE_TWO, BestMaxCard, 5);
			return;
		}

这里我们需要注意的是，因为i和j我们是放在一起减的，所以要保证i和j不能相等。即if (clsHandCardData.value_aHandCardList[j] > 1 && j != i)


四带二与其类似，无非就是再多一个循环。


四带二单：

for (int i = clsGameSituation.uctNowCardGroup.nMaxCard + 1; i < 16; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] == 4)
			{
				for (int j = 3; j < 18; j++)
				{
					//先选出一张以上的牌且不是选择四张的那个牌
					if (clsHandCardData.value_aHandCardList[j] > 0 && j != i)
					{
						//再选出一张以上的牌且不是选择四张的那个牌且不是第一次选的两张内个牌（策略里四带二不允许带一对,还不如炸）
						for (int k = j + 1; k < 18; k++)
						{
							if (clsHandCardData.value_aHandCardList[k] > 0 && k != i)
							{
								clsHandCardData.value_aHandCardList[i] -= 4;
								clsHandCardData.value_aHandCardList[j] -= 1;
								clsHandCardData.value_aHandCardList[k] -= 1;
								clsHandCardData.nHandCardCount -= 6;
								HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
								clsHandCardData.value_aHandCardList[i] += 4;
								clsHandCardData.value_aHandCardList[j] += 1;
								clsHandCardData.value_aHandCardList[k] += 1;
								clsHandCardData.nHandCardCount += 6;

								//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
								if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
								{
									BestHandCardValue = tmpHandCardValue;
									BestMaxCard = i;
									tmp_1 = j;
									tmp_2 = k;
									PutCards = true;
								}
							}
						}
					}
				}
			}
		}

四带二单的情况时k时从j+1开始算的，因为我们出牌的策略不允许四带二单带出去一个对，这样还不如直接炸了划算。若此处想修改的话，一定要注意判断i j k不能相等。

或者可以参考下一章处理飞机的方法，内个相对安全一些。


四带二的算法一样，都是修改枚举牌类型，出牌时value_nPutCardList的处理，回溯时value_aHandCardList和nHandCardCount这几处。


不过毕竟四带二这种牌型可以拆分出炸弹，所以我在选择四带二出牌前加入了一层判定：

/*本策略对于这种牌型有炸必炸，四带二相比炸弹来说会多带出两手牌，即最多提高14权值的价值
		若当前手牌价值大于14，即认为我们能炸即炸，不必考虑四带二的收益，就是这么任性。*/

		if (BestHandCardValue.SumValue > 14)
		{
			//炸弹——这里直接炸，不考虑拆分后果。因为信仰。
			for (int i = 3; i < 16; i++)
			{
				if (clsHandCardData.value_aHandCardList[i] == 4)
				{
					clsHandCardData.value_nPutCardList.push_back(i);
					clsHandCardData.value_nPutCardList.push_back(i);
					clsHandCardData.value_nPutCardList.push_back(i);
					clsHandCardData.value_nPutCardList.push_back(i);

					clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, i, 4);

					return;
				}
			}
			//王炸
			if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)
			{

				clsHandCardData.value_nPutCardList.push_back(17);
				clsHandCardData.value_nPutCardList.push_back(16);

				clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);

				return;
			}
		}

以及最后管不上出炸判断中，直接炸出。 

//这里是在拍权值较小的情况，且没有选择出良好的四带二牌型，那么也要炸，因为信仰。
		for (int i = 3; i < 16; i++)
		{
			if (clsHandCardData.value_aHandCardList[i] == 4)
			{
				clsHandCardData.value_nPutCardList.push_back(i);
				clsHandCardData.value_nPutCardList.push_back(i);
				clsHandCardData.value_nPutCardList.push_back(i);
				clsHandCardData.value_nPutCardList.push_back(i);

				clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, i, 4);

				return;
			}
		}
		//王炸
		if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)
		{

			clsHandCardData.value_nPutCardList.push_back(17);
			clsHandCardData.value_nPutCardList.push_back(16);

			clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);

			return;
		}


这个纯属个人信仰了，我觉得当对手打出四带二这种牌型，我有炸无论如何都是要炸的。

也就是对于四带二这种牌型我的出牌策略是：先看自己的手牌实力如何，如果较好直接炸。如果不太好，那么再看看以四带二形式管出后实力如何，如果较好，可以四带二管上，如果还是不太好，那么也是要炸，输就输了！！




本章我们把三带一、四带二牌型讲完了，下一章我们再完善剩余的飞机、炸弹牌型，也就是被动出牌最后的一部分了。所以~


敬请关注下一章：斗地主AI算法——第十一章の被动出牌(5)

java 斗地主出牌算法_斗地主AI算法——第七章の被动出牌(1)
weixin_35361243的博客
03-07 725
哎，之前扯了那么多蛋，终于讲出牌了！本章开始讲被动出牌的逻辑算法。首先我们先把架子搭起来，被动出牌我们肯定是要知道场上目前打出的是什么牌型。在第二章数据结构里我们定义过，游戏全局类里面有一个存放当前牌型结构的成员，即//当前打出牌的类型数据，被动出牌时玩家根据这里做出筛选CardGroupDatauctNowCardGroup;我们即将通过他进行类型的筛选，所以肯定是要枚举各类牌型的，也就是这个...
java 斗地主出牌算法_斗地主智能（AI）出牌算法
weixin_32973319的博客
02-13 3744
我以前写过一个斗地主机器人。思路如下，希望对你有帮助。};^}2Xo+斗地主AI设计}Fm\+JOS一、牌型7u|%^Ao61 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。QhsVIta2 炸弹：相同点数的四张牌在一起的牌型，比如四条A。除火箭外，它可以打任何牌型，炸弹对炸弹时，要比大小。-qfnUh3 单支(一手牌)：单张牌，如一支3。xdqK.Z%?4 对子(一手牌)：相...
斗地主出牌算法
shaogeiwojijiwaiwai的博客
03-16 1669
根据斗地主出牌规则.对玩家出的牌进行检验.判断是否符合出牌规则. (关于斗地主的出牌规则网上有很多) 思路:将玩家的牌按升序排序.然后将牌进行拆分,分存在4个数组中.拆分规则如下: 假设有牌:333\444\555\789 则拆分后数组中的数据如下 arr[0]:345789 arr[1]:345 arr[2]:345 arr[3]:null ...
斗地主出牌算法(as版)
08-21
本算法采用ActionScript3.0动态脚本语言编写,是网页FLASH版斗地主客户端的核心程序!
斗地主算法
12-18
斗地主算法源码，收集网上的一些文档，自己测试了一下，可以直接运行。代码比较简单易懂适合初学者
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
斗地主ai机器人出牌叫分算法cpp源码
05-04
自己开发的简单的斗地主陪练机器人出牌算法，c++代码，无需修改，直接使用。 使用方法： https://blog.youkuaiyun.com/hhpp526/article/details/103159283 解压密码：hhpp526@hotmail.com
斗地主AI 算法
06-04
【斗地主AI算法】是一种在计算机程序中实现人工智能，使其能够模拟人类玩家在斗地主游戏中的策略和决策过程的技术。在这个C#项目中，开发者已经创建了一个斗地主机器人，它能够根据预设的规则和算法进行智能打牌。...
基于权重的斗地主AI，基于权重的斗地主AI
05-24
斗地主是一款在中国广受欢迎的扑克游戏，而基于权重的斗地主AI是利用人工智能技术来模拟人类玩家的游戏策略。这种AI系统的核心在于通过权重分配来决定每一步操作的最优选择，以达到尽可能高的胜率。下面我们将深入...
斗地主AI算法——第十一章の被动出牌(5)
九日王朝
04-27 7316
本章是被动出牌的最后一章，截止目前，我们已经解决了大部分牌型。只剩下飞机和炸弹了。 飞机无疑是最复杂的类型，他等于顺子和三带的结合体，但又增加了很多难度。 根据上一章的算法，我们可以大概想到，若是带出去一张我就加一个循环，若是带出去两张我就加俩循环，但是这个飞机长度不一致，带出去的牌个数也就不一致，这TM怎么加啊！！我一开始的想法是外置一个全排列函数，给定count个数，然后列举所有的方案去改
斗地主智能（AI）出牌算法
热门推荐
xdx2ct1314的专栏
01-26 4万+
去年有想写个斗地主的小游戏，自己玩玩。找了很多资料，后来好不容易在网上找到了一个AI算法。转过的的时候是贴在自己电脑的TXT文本上，再次感谢下原作者。现在借花献佛发给你参考下。    我以前写过一个斗地主机器人。思路如下，希望对你有帮助。   斗地主AI设计  一、牌型           1 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。           2 炸弹
unity开发 斗地主算法—提示AI（提示出牌）
csdn_cjt的博客
11-27 8796
牌型的定义在http://blog.youkuaiyun.com/csdn_cjt/article/details/78593140 第一章 这是第四章 下面是代码 #region 提示出牌 public static Dictionary> FindPromptCards(List myCards, List lastCards, DDZ_P
7-9交换手牌
weixin_30911809的博客
07-09 158
import java.util.Scanner; public class D1 { public static void main(String[] args) { Scanner input=new Scanner (System.in); System.out.println("输出互换前手中的纸牌:"); System.out.print("请输入第一个数:"); in...
2020-09-14
qq_27054291的博客
09-14 1856
斗地主AI设计 一、牌型 1 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。 2 炸弹：相同点数的四张牌在一起的牌型，比如四条A。除火箭外，它可以打任何牌型，炸弹对炸~弹时，要比大小。 3 单支（一手牌）：单张牌，如一支3。 4 对子（一手牌）：相同点数的两张牌在一起的牌型，比如55。 5 三条：相同点数的三张牌在一起的牌型，比如三条4。 6 三带一手：三条 ＋ 一手牌的牌型，比如AAA+9或AAA+77。 7 单顺：五张或更多的连续单支牌组成的牌型，比如45678或345678910J
斗地主手牌 代码
quanfa206的博客
11-30 1137
using UnityEngine; using System.Collections; using System.Collections.Generic; /// /// 出牌规则 /// public class CardRules {     ///     /// 卡牌数组排序     ///     ///     ///     publi
斗地主AI
oiy37215的专栏
05-16 1791
斗地主 AI 设计 2009-02-05 20:02 斗地主 AI 设计     作者： wzwyc   发布时间： 2008-12-3 23:17:05    我以前写过一个斗地主机器人。思路如下，希望对你有帮助。   斗地主 AI 设计   一、牌型   1  火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。   2  炸
纸牌游戏：计算最小出牌次数（C#）
个人博客
05-26 1894
实现方式 C#递归计算每组牌型的对应组合，取最小组合数 注意定义：一组牌型意为单张3、对3、三张3、顺子、连对等 实现思路 要获取全部不重复（同值为重复）组合：纸牌游戏弹牌策略：获取全部牌型组合 通过这些不重复的组合计算 这里写自定义目录标题实现方式实现思路欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代...
斗地主出牌算法源码解析——C#实现
### 斗地主出牌算法知识点 #### 1. 斗地主游戏规则概述 斗地主是一种流行的扑克游戏，通常由三名玩家参与，使用一副54张的牌（包括两个王）。游戏的目标是尽快打出手中的牌。在斗地主中，牌的大小是有规定的，从大...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值