首先带来的就是麻将胡牌、听牌的算法，不过大家都知道，麻将各个地方的规则都不同，所以相关算法也需要作出一定的调整。

先简单说一下本次demo的规则要求把。

1.不计番，也就是没那么多胡法，最后胡了就行。

2.胡牌结构满足4*3+2即可，也就是4套组合（一个组合3张牌）+一个对子，组合可以是顺，也可以是碰。并且不要求必须有碰或者顺，可以是七对

3.有混牌（混牌就是什么都算，相当于癞子），本章demo不会实现，后续应该还会写几篇，敬请关注~

4.牌型有34种，即3*9=27基本牌型外加东南西北中发白7个风牌

大概就是这么多了 ，首先说明本章主要算法就是动态规划以及回溯，具体算法介绍可以参考以下博客

http://blog.csdn.net/sm9sun/article/details/53244484   回溯

http://blog.csdn.net/sm9sun/article/details/53240542   DP动态规划

另外说明以下代码只是初步的小demo，并未经过大量测试，极有可能出bug，敬请关注后续博客

废话不多说了，首先，我们要先思考一个问题，就是先算听牌还是先算胡牌？

这个问题很重要。如果你的算法用于听牌（13张），也就是你要返回相应的可以胡的牌的序列然后根据此序列判断接下来是否胡牌。相反，如果你的算法用于胡牌（14张）那么实际你听牌是采取手上的牌+1张枚举所有牌去检查是否可以胡牌。

看起来算胡牌的话每次听牌都要进行34次枚举实验或许会浪费时间，但是仔细想想，其实胡牌也有相应的好处，就是可以迅速剪枝掉不符合胡牌的情况。举个例子，如果你手上有1个一万，没二万，听牌算法还要考虑你是否有三万以及三万与后面牌型的关系。而胡牌算法简单粗暴返回一个false即可。

两种算法究竟哪个更好取决于其的剪枝程度，现在我还无法给出确定的结论，不过从我目前的思维来说，我更倾向于胡牌算法。

一些定义

[javascript] view plaincopy
  1. /*
  2. #define  0~8     万
  3. #define  9~17    饼
  4. #define  18~26   条
  5. #define  27      东
  6. #define  28      南
  7. #define  29      西
  8. #define  30      北
  9. #define  31      中
  10. #define  32      发
  11. #define  33      白
  12. */
  13. /*组牌信息
  14. * 采取状态压缩方法，对于每个牌类给出状态（0~4）
  15. * */
  16. var Mahjongtiles_info = {
  17. userID:-1,                   //对应用户ID
  18. in_Pai:new Array(34),        //手里的牌序列
  19. out_Pai:new Array(34),      //外面的牌序列
  20. sum_Pai:new Array(34),      //总和的牌序列
  21. };
  22. /*对局信息*/
  23. var Mahjonggame_info={
  24. player:Array(4),            //四个用户对应的组排
  25. hunPai:-1,                  //混牌
  26. zhuangjia:0,               //庄家
  27. PaiList:new Array(136),    //麻将队列
  28. };

注：PaiList为麻将队列，其还需初始化以及乱序等功能性函数

[javascript] view plaincopy
  1. /*麻将队列初始化*/
  2. function Init_List(arr){
  3. var index=0;
  4. for(var i=0;i<34;++i)
  5. {
  6. arr[index++]=i;
  7. arr[index++]=i;
  8. arr[index++]=i;
  9. arr[index++]=i;
  10. }
  11. }
  12. /*麻将队列乱序*/
  13. function shuffle_List(arr) {
  14. var i = arr.length, t, j;
  15. while (i) {
  16. j = Math.floor(Math.random() * i--);
  17. t = arr[i];
  18. arr[i] = arr[j];
  19. arr[j] = t;
  20. }
  21. }

那么采用胡牌算法的话，处理听牌就很简单了，枚举所有牌型

[javascript] view plaincopy
  1. /*判断是否可以听*/
  2. function CanTingPai(arr,TingArr){
  3. var ret=false;
  4. var result=false;
  5. for(var i = 0; i < 34; ++i)
  6. {
  7. // if(arr[i]<4) {             如果该牌玩家已经有4张了 是否还可以听此张 有待商榷
  8. arr[i]++;
  9. ret = CanHuPai(arr);
  10. arr[i]--;
  11. // }
  12. if(ret)
  13. {
  14. result=true;
  15. TingArr.push(i);
  16. }
  17. }
  18. return result;
  19. }

注：arr为状态记录的牌型数组，例如：arr[0]=3表示一万有三张

通过枚举调用CanHuPai函数验证，我们先写出相对简单的七小对胡牌规则进行验证

[javascript] view plaincopy
  1. /*是否为七对*/
  2. function CanHuPai__7pair(arr){
  3. var pairCount=0;
  4. /*七对*/
  5. for(var k in arr) {
  6. var c = arr[k];
  7. if (c == 2) {
  8. pairCount++;
  9. }
  10. else if (c == 4) {
  11. pairCount += 2;
  12. }
  13. else if( c != 0)   //当c不满足0,2,4情况即有单张出现，直接返回false
  14. {
  15. return false;
  16. }
  17. }
  18. if(pairCount==7)
  19. {
  20. return true;
  21. }
  22. else
  23. {
  24. return false;
  25. }
  26. }
[javascript] view plaincopy
  1. /*判断是否可以胡，枚举几类胡法*/
  2. function CanHuPai(arr){
  3. if(CanHuPai__7pair(arr))
  4. {
  5. return true;
  6. }
  7. else if(CanHuPai_norm(arr))
  8. {
  9. return true;
  10. }
  11. else
  12. {
  13. return false;
  14. }
  15. }

由于是初步的demo，先写出七小对和普通牌型的分支。

input：

[javascript] view plaincopy
  1. function SetTest(arr)
  2. {
  3. arr[1]+=2;
  4. arr[2]+=2;
  5. arr[3]+=2;
  6. arr[4]+=2;
  7. arr[5]+=4;
  8. arr[9]+=1;
  9. }

output：

9
true

然后是如何算胡牌。

第一步，先剔除对子使其成为3*4牌型。剔除对子的策略：

如果arr[i]==2即一对且其周围无法与其组合成一对顺子那么可以直接把其当成一对进入判胡环节

举个例子，我有两个二万，但是我一万+三万+四万总共不足4个，即无论怎么组合我这两个二万都没办法成为两组顺子

那么我这两个二万只能当做一对了，至于后面能不能胡先不管。

而arr[i]>2时则需要考虑 是否可以直接跳过而不进行剔除一对的判断。原理一样

比如arr[i]==4即有四个一样的，如果将其中两个剔除，另外两个不足与周围组合成两个顺子，那么显然这四个一样的是不可以拆成2+2的

arr[i]==3需要判断周围是否可以满足一个顺子

具体代码如下：

[javascript] view plaincopy
  1. /*针对于arr[i]=2情况的剪枝处理*/
  2. function Cancutpair_2(arr,i){
  3. if(i>26)    //如果为风牌则直接可以剔除对子
  4. {
  5. return true;                      //true为可以直接剔除，false为还需回溯
  6. }
  7. else if(i==0||i==9||i==18)         //一万 一饼 一条
  8. {
  9. if(arr[i+1]>=2&&arr[i+2]>=2) //如果对应的二与三都大等于2
  10. {
  11. return false;
  12. }
  13. else
  14. {
  15. return true;
  16. }
  17. }
  18. else if(i==8||i==17||i==26)         //九万 九饼 九条
  19. {
  20. if(arr[i-1]>=2&&arr[i-2]>=2) //如果对应的七与八都大等于2
  21. {
  22. return false;
  23. }
  24. else
  25. {
  26. return true;
  27. }
  28. }
  29. else if(i==1||i==10||i==19)         //二万 二饼 二条
  30. {
  31. if(arr[i-1]+arr[i+1]+arr[i+2]>=4&&arr[i+1]>=2)  //如果一+三+四大于4且三大于2
  32. {
  33. return false;
  34. }
  35. else
  36. {
  37. return true;
  38. }
  39. }
  40. else if(i==7||i==16||i==25)         //八万 八饼 八条
  41. {
  42. if(arr[i-1]+arr[i+1]+arr[i-2]>=4&&arr[i-1]>=2)  //如果九+七+六大于4且七大于2
  43. {
  44. return false;
  45. }
  46. else
  47. {
  48. return true;
  49. }
  50. }
  51. else if(arr[i-1]+arr[i+1]+arr[i-2]+arr[i+2]>=4)   //如果相邻的两端大于四张牌
  52. {
  53. return false;
  54. }
  55. else
  56. {
  57. return true;
  58. }
  59. }
  60. /*针对于arr[i]=3情况的剪枝处理，与 Cancutpair_2相反，当相邻牌数小于两张牌，则不可取*/
  61. function Cancutpair_3(arr,i){
  62. if(i>26)    //如果为风牌则不可以成为对子
  63. {
  64. return false;
  65. }
  66. else if(i==0||i==9||i==18)         //一万 一饼 一条
  67. {
  68. if(arr[i+1]>=1&&arr[i+2]>=1) //如果对应的二与三都大等于1
  69. {
  70. return true;
  71. }
  72. else
  73. {
  74. return false;
  75. }
  76. }
  77. else if(i==8||i==17||i==26)         //九万 九饼 九条
  78. {
  79. if(arr[i-1]>=1&&arr[i-2]>=1) //如果对应的七与八都大等于1
  80. {
  81. return true;
  82. }
  83. else
  84. {
  85. return false;
  86. }
  87. }
  88. else if(i==1||i==10||i==19)         //二万 二饼 二条
  89. {
  90. if(arr[i-1]+arr[i+2]>=1&&arr[i+1]>=1)  //如果一+四大等于1且三大等于1
  91. {
  92. return true;
  93. }
  94. else
  95. {
  96. return false;
  97. }
  98. }
  99. else if(i==7||i==16||i==25)         //八万 八饼 八条
  100. {
  101. if(arr[i+1]+arr[i-2]>=1&&arr[i-1]>=1)  //如果九+六大等于1且七大等于1
  102. {
  103. return true;
  104. }
  105. else
  106. {
  107. return false;
  108. }
  109. }
  110. else if(arr[i-1]+arr[i+1]+arr[i-2]+arr[i+2]>=2)   //如果相邻的两端大于两张牌
  111. {
  112. return true;
  113. }
  114. else
  115. {
  116. return false;
  117. }
  118. }
  119. /*针对于arr[i]=4情况的剪枝处理，与 Cancutpair_3相似，由于多出来两个，故当相邻牌数小于四张牌，则不可取*/
  120. function Cancutpair_4(arr,i){
  121. if(i>26)    //如果为风牌则不可以成为对子
  122. {
  123. return false;
  124. }
  125. else if(i==0||i==9||i==18)         //一万 一饼 一条
  126. {
  127. if(arr[i+1]>=2&&arr[i+2]>=2) //如果对应的二与三都大等于2
  128. {
  129. return true;
  130. }
  131. else
  132. {
  133. return false;
  134. }
  135. }
  136. else if(i==8||i==17||i==26)         //九万 九饼 九条
  137. {
  138. if(arr[i-1]>=2&&arr[i-2]>=2) //如果对应的七与八都大等于2
  139. {
  140. return true;
  141. }
  142. else
  143. {
  144. return false;
  145. }
  146. }
  147. else if(i==1||i==10||i==19)         //二万 二饼 二条
  148. {
  149. if(arr[i-1]+arr[i+2]>=2&&arr[i+1]>=2)  //如果一+四大等于2且三大等于2
  150. {
  151. return true;
  152. }
  153. else
  154. {
  155. return false;
  156. }
  157. }
  158. else if(i==7||i==16||i==25)         //八万 八饼 八条
  159. {
  160. if(arr[i-2]+arr[i+1]>=2&&arr[i-1]>=2)  //如果六+九大等于2且七大等于2
  161. {
  162. return true;
  163. }
  164. else
  165. {
  166. return false;
  167. }
  168. }
  169. else if(arr[i-1]+arr[i+1]+arr[i-2]+arr[i+2]>=4)   //如果相邻的两端大等于4
  170. {
  171. return true;
  172. }
  173. else
  174. {
  175. return false;
  176. }

同时，在判断胡牌前，加入剔除对子的调用

[javascript] view plaincopy
  1. function CanHuPai_norm(arr){
  2. var count =0;  //记录手牌总数
  3. for(var i = 0; i < 34; ++i) {
  4. count += arr[i];
  5. }
  6. /*剔除对子*/
  7. var ret=false;
  8. for(var i = 0; i < 34; ++i)
  9. {
  10. if(arr[i]==2)
  11. {
  12. if (Cancutpair_2(arr, i))
  13. {
  14. arr[i] -=2;     //直接剔除
  15. ret = CanHuPai_3N_recursive(arr,count-2,0);
  16. arr[i] +=2;
  17. return ret;
  18. }
  19. else {
  20. arr[i] -=2;
  21. ret = CanHuPai_3N_recursive(arr,count-2,0);
  22. arr[i] +=2;
  23. if(ret)              //如果满足可以返回，不满足还需要尝试其他的对子
  24. {
  25. return ret;
  26. }
  27. }
  28. }
  29. else if(arr[i]==3)
  30. {
  31. if (Cancutpair_3(arr, i))
  32. {
  33. arr[i] -=2;
  34. ret = CanHuPai_3N_recursive(arr,count-2,0);
  35. arr[i] +=2;
  36. if(ret)
  37. {
  38. return ret;
  39. }
  40. }
  41. }
  42. else if(arr[i]==4)
  43. {
  44. if (Cancutpair_4(arr, i))
  45. {
  46. arr[i] -=2;
  47. ret = CanHuPai_3N_recursive(arr,count-2,0);
  48. arr[i] +=2;
  49. if(ret)
  50. {
  51. return ret;
  52. }
  53. }
  54. }
  55. }
  56. return ret;
  57. }

好了，也就是说接下来我们只剩下一个判断剩下的牌是否可以组成n个组合了，也就是回溯调用的CanHuPai_3N_recursive

先说明以下参数，function CanHuPai_3N_recursive(arr,count,P)   arr为牌型数组，count为剩余手牌数，count==0时表示可以胡，P代表遍历当前牌ID的下标

也就是说，假设我P=8（九万）就意味着前面的1~8万我都处理了，都是0了，9万就不用进行更多的考虑了，如果9万是1张或者2张或者4张，那么直接返回false（因为对子已经剔除

1张或2张或4张又不可能与其他组合成一组）

[javascript] view plaincopy
  1. /*采取DP动态规划的思想
  2. *递归尝试消一组牌（3张），当arr所有值即count都为0时，即可以胡牌
  3. *count为剩余牌数
  4. * 当遇到冲突时，即不可以胡牌
  5. * */
  6. function CanHuPai_3N_recursive(arr,count,P) {
  7. //  process.stdout.write(arr +'\n'+count+'\n'+P+'\n');
  8. var ret=false;
  9. if(count==0)
  10. {
  11. return true;
  12. }
  13. if(P>26)        // 风牌只能组成碰
  14. {
  15. if(arr[P]==3)
  16. {
  17. ret=CanHuPai_3N_recursive(arr,count-3,P+1);
  18. return  ret;
  19. }
  20. else if(arr[P]==0)
  21. {
  22. ret=CanHuPai_3N_recursive(arr,count,P+1);
  23. return  ret;
  24. }
  25. else
  26. {
  27. return false;
  28. }
  29. }
  30. if(arr[P]==0){                                                //如果没有该牌，直接跳过进行下一张
  31. ret=CanHuPai_3N_recursive(arr,count,P+1);
  32. }
  33. if(arr[P]==1){
  34. if(P%9>6)                                                  //如果该牌是八或者九，则无法组合顺，不能胡
  35. {
  36. return false;
  37. }
  38. else if(arr[P+1]>0&&arr[P+2]>0)                         //能组合成顺
  39. {
  40. arr[P]--;
  41. arr[P+1]--;
  42. arr[P+2]--;
  43. ret=CanHuPai_3N_recursive(arr,count-3,P+1);
  44. arr[P]++;
  45. arr[P+1]++;
  46. arr[P+2]++;
  47. }
  48. else                                                    //无法组合顺，不能胡
  49. {
  50. return false;
  51. }
  52. }
  53. if(arr[P]==2){                                              //与1同理，组成两对顺
  54. if(P%9>6)
  55. {
  56. return false;
  57. }
  58. else if(arr[P+1]>1&&arr[P+2]>1)
  59. {
  60. arr[P]-=2;
  61. arr[P+1]-=2;
  62. arr[P+2]-=2;
  63. ret=CanHuPai_3N_recursive(arr,count-6,P+1);
  64. arr[P]+=2;
  65. arr[P+1]+=2;
  66. arr[P+2]+=2;
  67. }
  68. else
  69. {
  70. return false;
  71. }
  72. }
  73. if(arr[P]==3){
  74. ret=CanHuPai_3N_recursive(arr,count-3,P+1);             //当前需求 三对顺等同于三对碰
  75. /*
  76. if(P%9>6)
  77. {
  78. ret=CanHuPai_3N_recursive(arr,count-3,P+1);
  79. }
  80. else if(arr[P+1]>2&&arr[P+2]>2)
  81. {
  82. arr[P]-=3;
  83. arr[P+1]-=3;
  84. arr[P+2]-=3;
  85. ret=CanHuPai_3N_recursive(arr,count-9,P+1);
  86. arr[P]+=3;
  87. arr[P+1]+=3;
  88. arr[P+2]+=3;
  89. if(!ret)
  90. {
  91. arr[P + 1] += 3;
  92. arr[P + 2] += 3;
  93. ret=CanHuPai_3N_recursive(arr,count-3,P+1);
  94. arr[P + 1] -= 3;
  95. arr[P + 2] -= 3;
  96. }
  97. }
  98. else
  99. {
  100. ret=CanHuPai_3N_recursive(arr,count-3,P+1);
  101. }
  102. */
  103. }
  104. if(arr[P]==4) {                                       //如果为四张，则至少有一张与后面组成为顺，剩下的递归，P不变
  105. if(P%9>6)
  106. {
  107. return false;
  108. }
  109. else if (arr[P + 1] > 0 && arr[P + 2] > 0) {
  110. arr[P]--;
  111. arr[P + 1]--;
  112. arr[P + 2]--;
  113. ret = CanHuPai_3N_recursive(arr, count - 3, P );
  114. arr[P]++;
  115. arr[P + 1]++;
  116. arr[P + 2]++;
  117. }
  118. else
  119. {
  120. return false;
  121. }
  122. }
  123. /*
  124. console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
  125. process.stdout.write(arr +'\n');
  126. console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~');
  127. */
  128. return ret;
  129. }

其他测试需要的代码

[javascript] view plaincopy
  1. var start = new Date();
  2. var aMahjongtiles_info=Mahjongtiles_info;
  3. SetArrZero(aMahjongtiles_info.in_Pai);
  4. SetTest(aMahjongtiles_info.in_Pai);
  5. //var ret=CanHuPai(Mahjongtiles_info.in_Pai);
  6. //process.stdout.write(aMahjongtiles_info.in_Pai +'\n');
  7. var  Tinglist=new Array();
  8. var ret=CanTingPai(Mahjongtiles_info.in_Pai,Tinglist);
  9. process.stdout.write(Tinglist +'\n');
  10. console.log(ret);
  11. var end = new Date();
  12. console.log(start,end,end-start);

我们做一下测试吧，有一种牌型叫做九莲宝灯，即3个一万，3个九万加上二~八万各一张，其可以听所有的万子。

input

[javascript] view plaincopy
  1. /*指定测试样例*/
  2. function SetTest(arr)
  3. {
  4. arr[0+9]+=3;
  5. arr[1+9]+=1;
  6. arr[2+9]+=1;
  7. arr[3+9]+=1;
  8. arr[4+9]+=1;
  9. arr[5+9]+=1;
  10. arr[6+9]+=1;
  11. arr[7+9]+=1;
  12. arr[8+9]+=3;
  13. }

output

9,10,11,12,13,14,15,16,17
true
2017-03-23T12:32:45.654Z 2017-03-23T12:32:45.701Z 47

然后我们将其改一下，变成

[javascript] view plaincopy
  1. arr[9+9]+=3;
  2. arr[1+9]+=1;
  3. arr[2+9]+=1;
  4. arr[3+9]+=1;
  5. arr[4+9]+=1;
  6. arr[5+9]+=1;
  7. arr[6+9]+=1;
  8. arr[7+9]+=1;
  9. arr[8+9]+=3;

即一饼变成了一条

output

9,10,12,13,15,16
true
2017-03-23T12:33:34.041Z 2017-03-23T12:33:34.086Z 45

单吊二五八饼，边一四七饼    三六九饼不胡 答案应该是正确的~

恩，今天就到这里了，这只是一个初步的demo     代码+思路总共都是今天一天搞的，所以可能会有很多的问题

接下来会做更多剪枝方面的优化、BUG修改。包括混子牌什么的~

node.js——麻将算法（一）基本判胡相关推荐

  1. node.js——麻将算法（五）胡牌算法的一些优化处理方案（有赖子版）

    以前有赖子判胡算法 http://blog.csdn.net/sm9sun/article/details/65632646 以前的帖子说明了处理赖子的两种方案:枚举代替及插空补缺,并最终选择了枚举遍 ...

  2. node.js——麻将算法（四）胡牌算法的一些优化处理方案（无赖子版）

    回想三月份刚接触棋牌时写过一些麻将的算法,转眼间半年过去了,回顾下曾经的代码,写的还真是蛮low的 http://blog.csdn.net/sm9sun/article/details/654481 ...

  3. node.js——麻将算法（三）胡牌相关明牌

    最近在做一款叫做"卡五星"的三人麻将,来自湖北,麻将里只有筒和条(没有万)以及中发白这些牌. 其他的特殊功能暂且不提,其中有一个需求是玩家听牌后需要将与胡牌有关系的牌显示出来给其他 ...

  4. node.js——麻将算法（六）简易版麻将出牌AI1.0

    普通麻将的出牌AI如果不是要求特别高的话,其实蛮容易实现的,毕竟大多数人打牌都只是看自己的手牌. 所以作为简易版的AI,出牌的策略只要奔着胡牌去就可以了.我们能想到的就是把相邻或相同的牌凑到一起,把单 ...

  5. node.js——麻将算法（二）赖子玩法

    上篇博客传送门http://blog.csdn.net/sm9sun/article/details/65448140 上文中已经实现了基本胡法的算法,本章加入"癞子玩法"的判胡逻 ...

  6. node.js——麻将算法（七）简易版麻将出牌AI2.0

    *文本为上一篇博客http://blog.csdn.net/sm9sun/article/details/77898734的部分追加优化 上一篇博客已经实现了基本的出牌逻辑,大部分情况能够给出正确的策 ...

  7. 麻将算法（七）胡牌之对子判断

    判断一手牌中的牌是否可以胡牌,思路是选出将手牌中的对子,将手牌中的对子牌"去掉"后(将这个牌添加到一个叫DUIZI的list里),将去掉对子的手牌进行连牌与同牌判断 ,将" ...

  8. 基于QT和Node.js的八叉树算法提取图片主题色

    资源下载地址:https://download.csdn.net/download/sheziqiong/85883609 资源下载地址:https://download.csdn.net/downl ...

  9. Node.js复制/删除服务器端文件到指定目录文件夹下，并且预判是否存在该目录，如果没有，则递归创建该文件夹目录

    注意,前情提示: 本代码基于<Node.js(nodejs)对本地JSON文件进行增.删.改.查操作(轻车熟路)> 传送门Node.js(nodejs)对本地JSON文件进行增.删.改.查 ...

最新文章

  1. C语言获取当前工作路径
  2. 笔记-项目质量管理-编制质量管理计划的工具与技术
  3. cassandra连不上，报Stop listening for CQL clients, Failed managing commit log segments
  4. SpringBoot 注解大全
  5. Hbase中的列式表映射到hive的外表
  6. 单片机c语言pwm整流的程序,基于 单片机控制PWM整流电源的设计.doc
  7. qt最大化和还原实现_研究进展 | 水生所关于细菌异化型硝酸盐还原成铵与反硝化脱氮两种途径抉择的分子调控机制研究取得进展...
  8. 入职半年小结 | 给应届校招算法同学的几点建议
  9. android 底部加载更多,android:ScrollView滑动到底部显示加载更多(示例代码)
  10. C# 图像编程 (1) 准备工作; 你好，空姐; 为空姐照片添加特效
  11. php curl CURLOPT_TIMEOUT_MS 小于1秒 解决方案
  12. java qlv转mp4 代码_怎么将qlv格式转换成mp4？教你快速转换视频格式的技巧
  13. DLL劫持技术解析(DLL Hijack)
  14. application/json和application/x-www-form-urlencoded使用选择
  15. 【Vue基础】前端工程化Vue项目
  16. 3dmax骨骼的绑定
  17. 云服务器存储文件,云服务器存储文件
  18. 【PYTHON数据分析实战】电影票房数据分析(一)数据采集
  19. 计算机毕业设计ssm陈氏商城9pd36系统+程序+源码+lw+远程部署
  20. 【Window10】解决win10家庭中文版找不到组策略gpedit.msc修改不了C盘文件

热门文章

  1. windows10下，from skimage import morphology 报错的解决办法
  2. 7.Deep Interest Network for Click-Through Rate Prediction论文详解
  3. 沈阳农业大学计算机往年录取分数6,沈阳农业大学历年分数线 2021沈阳农业大学录取分数线...
  4. 计算机管理信息系统大作业,管理信息系统期末大作业
  5. [k8s] 第十章 DashBoard
  6. @AUTORELEASEPOOL
  7. instancesRespondToSelector与respondsToSelector的区别
  8. java.lang.NullPointerException空指针问题
  9. python实现文件搜索_python实现搜索指定目录下文件及文件内搜索指定关键词的方法...
  10. 超赞的贪吃蛇、吃豆人和数字华容道等童年小游戏1行Python代码就能玩