带财神和白搭胡牌算法
//分析扑克
bool CGameLogic::AnalyseCard(const BYTE cbCardIndex[MAX_INDEX], tagWeaveItem WeaveItem[], BYTE cbWeaveCount, CAnalyseItemArray & AnalyseItemArray)
{
//计算数目
BYTE cbCardCount=0;
for (BYTE i=0;i<MAX_INDEX;i++)
cbCardCount+=cbCardIndex[i];
//效验数目
ASSERT((cbCardCount>=2)&&(cbCardCount<=MAX_COUNT)&&((cbCardCount-2)%3==0));
if ((cbCardCount<2)||(cbCardCount>MAX_COUNT)||((cbCardCount-2)%3!=0))
return false;
//变量定义
BYTE cbKindItemCount=0;
//tagKindItem KindItem[MAX_COUNT-2];
tagKindItem KindItem[27*2+7+28];
ZeroMemory(KindItem,sizeof(KindItem));
//需求判断
BYTE cbLessKindItem=(cbCardCount-2)/3;
ASSERT((cbLessKindItem+cbWeaveCount)==MAX_WEAVE);
BYTE byGodsIndex = SwitchToCardIndex(m_byGodsCardData);
BYTE m_BaiBanIndex=SwitchToCardIndex(BAIBAN_CARD_DATA);
//单吊判断
if (cbLessKindItem==0)
{
//效验参数
ASSERT((cbCardCount==2)&&(cbWeaveCount==MAX_WEAVE));
//牌眼判断
for (BYTE i=0;i<MAX_INDEX;i++)
{
if ((cbCardIndex[i]==2)
|| ((cbCardIndex[i]==1)
&& (i != byGodsIndex)
&& (cbCardIndex[byGodsIndex]>0)))
{
//变量定义
tagAnalyseItem AnalyseItem;
ZeroMemory(&AnalyseItem,sizeof(AnalyseItem));
//设置结果
for (BYTE j=0;j<cbWeaveCount;j++)
{
AnalyseItem.cbWeaveKind[j]=WeaveItem[j].cbWeaveKind;
AnalyseItem.cbCenterCard[j]=WeaveItem[j].cbCenterCard;
}
AnalyseItem.cbCardEye=SwitchToCardData(i);
if(cbCardIndex[byGodsIndex]>0 && i!=byGodsIndex && cbCardIndex[i]==1)
{
AnalyseItem.cbEye=SwitchToCardData(byGodsIndex);
AnalyseItem.cbMyEye=true;
}
//插入结果
AnalyseItemArray.Add(AnalyseItem);
return true;
}
}
return false;
}
BYTE magicCount=0;
magicCount=cbCardIndex[SwitchToCardIndex(m_byGodsCardData)];
把白板转换为财神
//int cbTemp1=cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]; //财神数
//int cbTemp2=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]; //白板数
cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)];
转换数
//int bConverNum=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)];
财神数 =财神+白板数
//cbTemp1+=bConverNum;
//拆分分析
//BYTE cbMagicCardIndex[MAX_INDEX];
//CopyMemory(cbMagicCardIndex,cbCardIndex,sizeof(cbMagicCardIndex));
如果有财神
//BYTE cbMagicCardCount = 0;
//if( m_cbMagicIndex != MAX_INDEX )
//{
// cbMagicCardCount = cbCardIndex[m_cbMagicIndex];
// //如果财神有代替牌，财神与代替牌转换
// if( INDEX_REPLACE_CARD != MAX_INDEX )
// {
// cbMagicCardIndex[m_cbMagicIndex] = cbMagicCardIndex[INDEX_REPLACE_CARD];
// cbMagicCardIndex[INDEX_REPLACE_CARD] = cbMagicCardCount;
// }
//}
//白板个数
int cbBaiBan=cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)];
// 拆分分析
if (cbCardCount>=3)
{
for (BYTE i=0;i<MAX_INDEX;i++)
{
//同牌判断
/*if (cbCardIndex[i]>=3)
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;
KindItem[cbKindItemCount].cbCardIndex[1]=i;
KindItem[cbKindItemCount].cbCardIndex[2]=i;
KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
}*/
// log.Log("报错",信息);
//log.Log(i,信息);
/*for(int t=0;t<14;++t)
{
log.Log(t,信息);
log.Log(cbCardIndex[t],信息);
}*/
// log.Log(cbCardIndex[i],信息);
//同牌判断
if(cbCardIndex[i]+cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]>=3)
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;//cbCardIndex[i]>0?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[1]=i;//cbCardIndex[i]>1?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[2]=i;//cbCardIndex[i]>2?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
KindItem[cbKindItemCount].cbValidIndex[0] = cbCardIndex[i]>0?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbValidIndex[1] = cbCardIndex[i]>1?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbValidIndex[2] = cbCardIndex[i]>2?i:SwitchToCardIndex(m_byGodsCardData);
cbKindItemCount++;
if(cbCardIndex[i]+cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]>=6)
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;//cbCardIndex[i]>3?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[1]=i;//SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[2]=i;//SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
KindItem[cbKindItemCount].cbValidIndex[0] = cbCardIndex[i]>3?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbValidIndex[1] = SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbValidIndex[2] = SwitchToCardIndex(m_byGodsCardData);
cbKindItemCount++;
}
}
// log.Log("同牌",信息);
//同牌判断
//如果是财神,并且财神数小于3,则不进行组合
//if( cbMagicCardIndex[i] >= 3 || ( cbMagicCardIndex[i]+cbMagicCardCount >= 3 &&
// ( /*( INDEX_REPLACE_CARD!=MAX_INDEX && */i != INDEX_REPLACE_CARD ) /*|| ( INDEX_REPLACE_CARD==MAX_INDEX && i != m_cbMagicIndex )*/ ) )
//
//{
// int nTempIndex = cbMagicCardIndex[i];
// do
// {
// ASSERT( cbKindItemCount < CountArray(KindItem) );
// BYTE cbIndex = i;
// BYTE cbCenterCard = SwitchToCardData(i);
// //如果是财神且财神有代替牌,则换成代替牌
// if( i == m_cbMagicIndex && INDEX_REPLACE_CARD != MAX_INDEX )
// {
// cbIndex = INDEX_REPLACE_CARD;
// cbCenterCard = SwitchToCardData(INDEX_REPLACE_CARD);
// }
// KindItem[cbKindItemCount].cbWeaveKind=WIK_PENG;
// KindItem[cbKindItemCount].cbCenterCard=cbCenterCard;
// KindItem[cbKindItemCount].cbValidIndex[0] = nTempIndex>0?cbIndex:m_cbMagicIndex;
// KindItem[cbKindItemCount].cbValidIndex[1] = nTempIndex>1?cbIndex:m_cbMagicIndex;
// KindItem[cbKindItemCount].cbValidIndex[2] = nTempIndex>2?cbIndex:m_cbMagicIndex;
// cbKindItemCount++;
// //如果是财神,则退出
// if( i == INDEX_REPLACE_CARD || (i == m_cbMagicIndex && INDEX_REPLACE_CARD == MAX_INDEX) )
// break;
// nTempIndex -= 3;
// //如果刚好搭配全部，则退出
// if( nTempIndex == 0 ) break;
// }while( nTempIndex+cbMagicCardCount >= 3 );
//}
//如果是财神,变成白板
/*if(i==SwitchToCardIndex(m_byGodsCardData))
{
}*/
// 连牌判断
//if ((i<(MAX_INDEX-/*MAX_HUA_CARD*/-9))&&((i%9)<7))
//{
// //只要财神牌数加上3个顺序索引的牌数大于等于3,则进行组合
// if( cbMagicCardCount+cbMagicCardIndex[i]+cbMagicCardIndex[i+1]+cbMagicCardIndex[i+2] >= 3 )
// {
// BYTE cbIndex[3] = { cbMagicCardIndex[i],cbMagicCardIndex[i+1],cbMagicCardIndex[i+2] };
// int nMagicCountTemp = cbMagicCardCount;
// BYTE cbValidIndex[3];
// while( nMagicCountTemp+cbIndex[0]+cbIndex[1]+cbIndex[2] >= 3 )
// {
// for( BYTE j = 0; j < CountArray(cbIndex); j++ )
// {
// if( cbIndex[j] > 0 )
// {
// cbIndex[j]--;
// cbValidIndex[j] = (i+j==m_cbMagicIndex&&INDEX_REPLACE_CARD!=MAX_INDEX)?INDEX_REPLACE_CARD:i+j;
// }
// else
// {
// nMagicCountTemp--;
// cbValidIndex[j] = m_cbMagicIndex;
// }
// }
// if( nMagicCountTemp >= 0 )
// {
// ASSERT( cbKindItemCount < CountArray(KindItem) );
// KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
// KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
// CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
// cbKindItemCount++;
// }
// else break;
// }
// }
//}
if((i<27)&&(i%9)<7)
{
if((cbCardIndex[SwitchToCardIndex(m_byGodsCardData)]+cbCardIndex[i]+cbCardIndex[i+1]+cbCardIndex[i+2])>=3
||(cbCardIndex[i]+cbCardIndex[i+1]+cbCardIndex[i+2]+cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)])>=3 )
{
/* BYTE cbIndex[3]={i==SwitchToCardIndex(m_byGodsCardData)?0:cbCardIndex[i],(i+1)==SwitchToCardIndex(m_byGodsCardData)?0:cbCardIndex[i+1],
(i+2)==SwitchToCardIndex(m_byGodsCardData)?0:cbCardIndex[i+2]};*/
//如果连牌是财神,判断有没有白板,有白板则用白板换
BYTE cbIndex[3]={i==SwitchToCardIndex(m_byGodsCardData)?cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]:cbCardIndex[i],
(i+1)==SwitchToCardIndex(m_byGodsCardData)?cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]:cbCardIndex[i+1],
(i+2)==SwitchToCardIndex(m_byGodsCardData)?cbCardIndex[SwitchToCardIndex(BAIBAN_CARD_DATA)]:cbCardIndex[i+2]};
int magicCount=cbCardIndex[SwitchToCardIndex(m_byGodsCardData)];
BYTE cbValidIndex[3];
int bl=1;
while((bl=(magicCount+cbIndex[0]+cbIndex[1]+cbIndex[2]))>=3)
{
for(BYTE j=0;j<3;++j)
{
if(cbIndex[j]>0)
{
cbIndex[j]--;
//如果是财神,换成白板
cbValidIndex[j]=(i+j)==SwitchToCardIndex(m_byGodsCardData)?SwitchToCardIndex(BAIBAN_CARD_DATA):(i+j);
}
else
{
magicCount--;
cbValidIndex[j]=SwitchToCardIndex(m_byGodsCardData);
}
}
if(magicCount>=0)
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;//cbCardIndex[i]>3?i:SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[1]=i+1;//SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbCardIndex[2]=i+2;//SwitchToCardIndex(m_byGodsCardData);
KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
KindItem[cbKindItemCount].cbCenterCard=SwitchToCardData(i);
CopyMemory( KindItem[cbKindItemCount].cbValidIndex,cbValidIndex,sizeof(cbValidIndex) );
cbKindItemCount++;
}
else break;
}
}
}
// log.Log("连牌",信息);
/*if ((i<(MAX_INDEX-9))&&(cbCardIndex[i]>0)&&((i%9)<7))
{
for (BYTE j=1;j<=cbCardIndex[i];j++)
{
if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
{
KindItem[cbKindItemCount].cbCardIndex[0]=i;
KindItem[cbKindItemCount].cbCardIndex[1]=SwitchToCardIndex(i)-1;
KindItem[cbKindItemCount].cbCardIndex[2]=SwitchToCardIndex(i)-1;
KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
}
}
}*/
//连牌判断
/*if((i)==SwitchToCardData(BAIBAN_CARD_DATA))
{
}*/
//连牌判断
//if((i)==SwitchToCardIndex(BAIBAN_CARD_DATA))
//{
// for(BYTE j=1;j<=cbCardIndex[i];++j)
// {
// // if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
// if((cbCardIndex[SwitchToCardIndex(i)-2]>=j)&&(cbCardIndex[SwitchToCardIndex(i)-1]>=j))
// {
// KindItem[cbKindItemCount].cbCardIndex[0]=SwitchToCardIndex(m_byGodsCardData)-2;//i-2
// KindItem[cbKindItemCount].cbCardIndex[1]=SwitchToCardIndex(m_byGodsCardData)-1;//i-1;
// KindItem[cbKindItemCount].cbCardIndex[2]=i;//i;
// KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
// KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
// }
// }
//}
连牌判断
//if((i)==SwitchToCardIndex(BAIBAN_CARD_DATA))
//{
// for(BYTE j=1;j<=cbCardIndex[i];++j)
// {
// // if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
// if((cbCardIndex[SwitchToCardIndex(m_byGodsCardData)-1]>=j)&&(cbCardIndex[SwitchToCardIndex(m_byGodsCardData)+1]>=j))
// {
// KindItem[cbKindItemCount].cbCardIndex[0]=SwitchToCardIndex(m_byGodsCardData)-1;//i-2
// KindItem[cbKindItemCount].cbCardIndex[1]=i;//i-1;
// KindItem[cbKindItemCount].cbCardIndex[2]=SwitchToCardIndex(m_byGodsCardData)+1;//i;
// KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
// KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
// }
//
// }
//}
连牌判断
//if((i)==SwitchToCardIndex(BAIBAN_CARD_DATA))
//{
// for(BYTE j=1;j<=cbCardIndex[i];++j)
// {
// // if ((cbCardIndex[i+1]>=j)&&(cbCardIndex[i+2]>=j))
// if((cbCardIndex[SwitchToCardIndex(m_byGodsCardData)+1]>=j)&&(cbCardIndex[SwitchToCardIndex(m_byGodsCardData)+2]>=j))
// {
// KindItem[cbKindItemCount].cbCardIndex[0]=i;
// KindItem[cbKindItemCount].cbCardIndex[1]=SwitchToCardIndex(m_byGodsCardData)+1;//i+1;
// KindItem[cbKindItemCount].cbCardIndex[2]=SwitchToCardIndex(m_byGodsCardData)+2;//i+2;
// KindItem[cbKindItemCount].cbWeaveKind=WIK_LEFT;
// KindItem[cbKindItemCount++].cbCenterCard=SwitchToCardData(i);
// }
//
// }
//}
}
}
//组合分析
if (cbKindItemCount>=cbLessKindItem)
{
// log.Log("cbKindItemCount",信息);
//变量定义
BYTE cbCardIndexTemp[MAX_INDEX];
ZeroMemory(cbCardIndexTemp,sizeof(cbCardIndexTemp));
//变量定义
BYTE cbIndex[MAX_WEAVE]={0,1,2,3};
tagKindItem * pKindItem[MAX_WEAVE];
ZeroMemory(&pKindItem,sizeof(pKindItem));
//开始组合
do
{
//设置变量
CopyMemory(cbCardIndexTemp,cbCardIndex,sizeof(cbCardIndexTemp));
for (BYTE i=0;i<cbLessKindItem;i++)
pKindItem[i]=&KindItem[cbIndex[i]];
//数量判断
bool bEnoughCard=true;
for (BYTE i=0;i<cbLessKindItem*3;i++)
{
//存在判断
//BYTE cbCardIndex=pKindItem[i/3]->cbCardIndex[i%3];
BYTE cbCardIndex=pKindItem[i/3]->cbValidIndex[i%3];
if (cbCardIndexTemp[cbCardIndex]==0)
{
if(cbCardIndexTemp[SwitchToCardIndex(m_byGodsCardData)]>0)
{
cbCardIndexTemp[SwitchToCardIndex(m_byGodsCardData)]--;
// pKindItem[i/3]->cbValidIndex[i%3] =SwitchToCardIndex(m_byGodsCardData);
}
else
{
bEnoughCard=false;
break;
}
}
else
cbCardIndexTemp[cbCardIndex]--;
}
//胡牌判断
if (bEnoughCard==true)
{
//log.Log("判胡",信息);
//牌眼判断
BYTE cbCardEye=0;
BYTE cbEye=0;
bool cbMyEye=false;
for (BYTE i=0;i<MAX_INDEX;i++)
{
if (cbCardIndexTemp[i]==2)
{
cbCardEye=SwitchToCardData(i);
break;
}
else if(cbCardIndexTemp[i]+cbCardIndexTemp[SwitchToCardIndex(m_byGodsCardData)]==2 && (i!=SwitchToCardIndex(m_byGodsCardData)))
{
cbCardEye=SwitchToCardData(i);
//cbCardEye=m_byGodsCardData;
cbEye=m_byGodsCardData;
cbMyEye=true;
break;
}
}
//组合类型
if (cbCardEye!=0)
{
//变量定义
tagAnalyseItem AnalyseItem;
ZeroMemory(&AnalyseItem,sizeof(AnalyseItem));
//设置组合
for (BYTE i=0;i<cbWeaveCount;i++)
{
AnalyseItem.cbWeaveKind[i]=WeaveItem[i].cbWeaveKind;
AnalyseItem.cbCenterCard[i]=WeaveItem[i].cbCenterCard;
}
//设置牌型
for (BYTE i=0;i<cbLessKindItem;i++)
{
AnalyseItem.cbWeaveKind[i+cbWeaveCount]=pKindItem[i]->cbWeaveKind;
AnalyseItem.cbCenterCard[i+cbWeaveCount]=pKindItem[i]->cbCenterCard;
}
//设置牌型
/*for(BYTE i=0;i<cbLessKindItem;++i)
{
AnalyseItem.cbWeaveKind[i+cbWeaveCount]=WeaveItem[i].cbWeaveKind;
AnalyseItem.cbCardData[i+cbWeaveCount][0]=SwitchToCardData(pKindItem[i].cbValidIndex[0]);
AnalyseItem.cbCardData[i+cbWeaveCount][1]=SwitchToCardData(pKindItem[i].cbValidIndex[0]);
AnalyseItem.cbCardData[i+cbWeaveCount][2]=SwitchToCardData(pKindItem[i].cbValidIndex[0]);
}*/
//设置牌眼
AnalyseItem.cbCardEye=cbCardEye;
AnalyseItem.cbEye=cbEye;
AnalyseItem.cbMyEye=cbMyEye;
//插入结果
AnalyseItemArray.Add(AnalyseItem);
}
}
//设置索引
if (cbIndex[cbLessKindItem-1]==(cbKindItemCount-1))
{
BYTE i=0;
for (i=cbLessKindItem-1;i>0;i--)
{
if ((cbIndex[i-1]+1)!=cbIndex[i])
{
BYTE cbNewIndex=cbIndex[i-1];
for (BYTE j=(i-1);j<cbLessKindItem;j++)
cbIndex[j]=cbNewIndex+j-i+2;
break;
}
}
if (i==0)
break;
}
else
cbIndex[cbLessKindItem-1]++;
} while (true);
}
// log.Log("胡牌判完",信息);
return (AnalyseItemArray.GetCount()>0);
}
带财神和白搭胡牌算法相关推荐
- 麻将胡牌算法带癞子 python实现
姐姐:你去帮我和闺蜜打麻将? 学霸哥哥:可是我不会打麻将呀! 姐姐:你不是学霸吗?我教你一个麻将公式,我闺蜜可是单身哟! 学霸哥哥:什么公式? 姐姐:麻将胡牌公式: AAA*M+ABC*N+BB,WM ...
- 带赖子的麻将胡牌算法Java_有人讨论下麻将胡牌，出牌算法吗，求思路
前段时间学会了打麻将,觉得老祖宗的智慧真的博大精深,很好玩,食胡的时候真兴奋啊,于是空余时间就想自己写个麻将游戏出来,模仿欢乐麻将那种,数学差,想了两个礼拜才想出一个胡牌算法,前段时间学会了打麻将. ...
- 可带癞子的通用麻将胡牌算法
本文原创文章,转载注明出处,博客地址 https://segmentfault.com/u/to... 第一时间看后续精彩文章.觉得好的话,顺手分享到朋友圈吧,感谢支持. 笔者前段时间做过一款地方麻将 ...
- 麻将胡牌算法，带癞子
貌似去年去面试一家公司,问了麻将的算法.虽然之前做过广东麻将,但是胡牌算法在服务端,就没有在意. 现在在网上搜了一些算法试了试 = =! 麻将普通的胡牌就是刻子+顺子+将.癞子可以充当任意一张牌. 参 ...
- 跑胡子c语言算法,跑胡子胡牌算法Java版(带赖子、基于回溯算法)
跑胡子规则 跑胡子,小写"一"到"十"各4张共40张,大写"壹"到"拾"各4张共40张. 砌牌:跑胡子为3人同玩,庄家砌 ...
- 跑胡子胡牌算法(带赖子、基于回溯算法)
跑胡子规则 跑胡子,小写"一"到"十"各4张共40张,大写"壹"到"拾"各4张共40张. 砌牌:跑胡子为3人同玩,庄家砌 ...
- 棋牌麻将 - 无癞子胡牌算法(第三版)
基础知识 本文涉及的所有名词均在博文中有说明: http://blog.csdn.net/kunyus/article/details/78644517 测试结果 测试环境: MEM: 4 GB CP ...
- 麻将通用胡牌算法详解(拆解法)
1.背景 前几天刚好有项目需要胡牌算法,查阅资料后,大部分胡牌算法的博客都是只讲原理,实现太过简单,且没有给出测试用例.然后就有了下面的这个胡牌算法,我将从算法原理和算法实现两部分展开,想直接用的,直 ...
- 麻将胡牌算法 极速(速度接近理论极限)
此麻将胡牌算法优点: 1.可处理多赖子牌(万能牌) 2.算法速度极快:1ms可大约计算1W+副手牌是否可胡(带赖子.0.08us左右),不带赖子的牌型更快.(最新版的算法速度感觉已很接近理论极限值) ...
最新文章
- 《数学之美》第7章 贾里尼克和现代语言处理
- [content-description] find_element_by_accessibility_id 在 android 中的详解
- 今目标戴珂:掘金企业协同
- zabbix客户端安装二
- Python自学笔记-列表生成式（来自廖雪峰的官网Python3）
- node.js升级后原来的Ionic项目跑不起来了解决方法
- Linux环境中Qt程序的手工发布
- cvtColor不是cv的成员
- 【五级流水线CPU】—— 7. 协处理器访问指令(2条)
- Nginx安装，目录结构与配置文件详解
- CentOS安装后初始配置
- java编译速度_[译] Kotlin VS Java:编译速度大比拼
- spring的依赖注入的方式（待更新）
- 3PAR存储双活LUN扩容方法
- mongoose时间自动转化为格林尼治标准时间的解决方案
- 小程序 wepy+MinUI
- 微信小程序 之wx.previewImage图片预览(多张图片预览)
- 完美解决Xmind打开乱码的问题
- 工厂自动化的生产线属于计算机应用,计算机试题
- 特征工程-什么是特征工程（Kaggle微课）