我有一副24张牌--8张红牌，8张蓝牌和8张黄牌。
red |1|2|3|4|5|6|7|8|
yellow |1|2|3|4|5|6|7|8|
blue |1|2|3|4|5|6|7|8|
我可以拿3张牌（相同数字，笔直，直线齐平），而每种类型的得分都不同。 我的问题是，如何计算正在进行的游戏的最大可能得分（找到最佳组），其中一些卡已经丢失。 例如：
red |1|2|3|4|5|6|7|8|
yellow |1|2|3| |5| |7|8|
blue |1|2| |4|5|6| |8|
三种类型的得分是：
1-1-1 20
2-2-2 30
3-3-3 40
4-4-4 50
5-5-5 60
6-6-6 70
7-7-7 80
8-8-8 90
直道的得分是：
1-2-3 10
2-3-4 20
3-4-5 30
4-5-6 40
5-6-7 50
6-7-8 60
同花顺的得分是：
1-2-3 50
2-3-4 60
3-4-5 70
4-5-6 80
5-6-7 90
6-7-8 100
答案 0 :(得分：1)
递归尝试每个组合的解决方案将如下所示：
开始查看具有红色8作为最高牌的组合：三种r8-y8-b8，直接冲洗r6-r7-r8，以及每种可能的直线* 6- * 7-r8。对于其中的每一个，从集合中取出卡片，并递归检查与黄色8，然后是蓝色8，然后是红色7，黄色7，蓝色7，红色6 ......的组合，直到您检查了除了2＆1和1;然后添加三种2-2-2和1-1-1（如果有的话）。在每个步骤中，检查哪个递归返回最大分数，并返回此最大值。
让我们看看每个步骤中会发生什么。假设我们正在寻找红色8的组合;我们有可用的卡片：
red ...|6|7|8|
yellow ...|6| |8|
blue ...| |7|8|
首先，如果可能的话，使用三种r8-y8-b8。创建可用卡片的副本，删除8，然后直接递归到7：
score = 90 + max_score(cards_copy, next = red 7)
（尝试三种类型只能在当前卡片为红色时进行，以避免重复解决方案。）
然后，如果可能的话，使用直接冲洗r6-r7-r8。创建可用卡片的副本，删除r6，r7和r8，并递归到黄色8：
score = 100 + max_score(cards_copy, next = yellow 8)
然后，使用包含红色8的每个可能的非冲洗直线;在这个例子中，那些是r6-b7-r8，y6-r7-r8和y6-b7-r8（最多可以有9个）。对于其中每一个，创建可用卡的副本，删除三张卡并递归到黄色8：
score = 60 + max_score(cards_copy, next = yellow 8)
然后，最后，不使用红色8递归：创建可用卡片的副本，删除红色8并递归到黄色8：
score = max_score(cards_copy, next = yellow 8)
然后，您可以计算出哪些选项的分数最高（添加了递归返回的分数），并返回该最高分数。
JavaScript中的快速测试显示，对于一整套24张卡，算法会经历3000万次递归以找到最高分560，并且变得非常慢。然而，一旦删除了3张更高价值的牌，递归次数就会减少到100万以下，大约需要1秒钟，并且有6张更高价值的牌被删除，它会低于20,000而几乎立即返回。
对于几乎完整的集合，您可以预先计算最大分数，并且只有在删除一定数量的卡片后才计算分数。无论如何，很多套都会重复;去除r6-r7-r8将导致与删除y6-y7-y8相同的最大分数;删除r6-y7-b8是删除b6-y7-r8的副本...首先，您将输入更改为规范版本，然后查找预先计算的分数。例如。如果使用3或6张卡片的所有套装使用预先计算的分数，则需要存储45,340个分数。
作为一个代码示例，这里是我用以下方法测试算法的JavaScript代码：
function clone(array) { // copy 2-dimensional array
var copy = [];
array.forEach(function(item) {copy.push(item.slice())});
return copy;
}
function max_score(cards, suit, rank) {
suit = suit || 0; rank = rank || 7; // start at red 8
var max = 0;
if (rank < 2) { // try 3-of-a-kind for rank 1 and 2
if (cards[0][0] && cards[1][0] && cards[2][0]) max += 20;
if (cards[0][1] && cards[1][1] && cards[2][1]) max += 30;
return max;
}
var next_rank = suit == 2 ? rank - 1: rank;
var next_suit = (suit + 1) % 3;
max = max_score(clone(cards), next_suit, next_rank); // try skipping this card
if (! cards[suit][rank]) return max;
if (suit == 0 && cards[1][rank] && cards[2][rank]) { // try 3-of-a-kind
var score = rank * 10 + 20 + max_score(clone(cards), 0, rank - 1);
if (score > max) max = score;
}
for (var i = 0; i < 3; i++) { // try all possible straights
if (! cards[i][rank - 2]) continue;
for (var j = 0; j < 3; j++) {
if (! cards[j][rank - 1]) continue;
var copy = clone(cards);
copy[j][rank - 1] = 0; copy[i][rank - 2] = 0;
var score = rank * 10 - 10 + max_score(copy, next_suit, next_rank);
if (i == suit && j == suit) score += 40; // straight is straight flush
if (score > max) max = score;
}
}
return max;
}
document.write(max_score([[1,1,1,1,1,0,1,1], [1,1,1,1,1,1,1,0], [1,1,1,0,1,1,1,1]]));
加速算法的一个明显方法是使用24位模式而不是3x8位数组来表示卡;这样就不再需要进行数组克隆了，而且大部分代码都变成了位操作。在JavaScript中，它的速度提高了大约8倍：
function max_score(cards, suit, rank) {
suit = suit || 0; rank = rank || 7; // start at red 8
var max = 0;
if (rank < 2) { // try 3-of-a-kind for rank 1 and 2
if ((cards & 65793) == 65793) max += 20; // 65793 = rank 1 of all suits
if ((cards & 131586) == 131586) max += 30; // 131586 = rank 2 of all suits
return max;
}
var next_rank = suit == 2 ? rank - 1: rank;
var next_suit = (suit + 1) % 3;
var this_card = 1 << rank << suit * 8;
max = max_score(cards, next_suit, next_rank); // try skipping this card
if (! (cards & this_card)) return max;
if (suit == 0 && cards & this_card << 8 && cards & this_card << 16) { // try 3oaK
var score = rank * 10 + 20 + max_score(cards, 0, rank - 1);
if (score > max) max = score;
}
for (var i = 0; i < 3; i++) { // try all possible straights
var mid_card = 1 << rank - 1 << i * 8;
if (! (cards & mid_card)) continue;
for (var j = 0; j < 3; j++) {
var low_card = 1 << rank - 2 << j * 8;
if (! (cards & low_card)) continue;
var cards_copy = cards - mid_card - low_card;
var score = rank * 10 - 10 + max_score(cards_copy, next_suit, next_rank);
if (i == suit && j == suit) score += 40; // straight is straight flush
if (score > max) max = score;
}
}
return max;
}
document.write(max_score(parseInt("111101110111111111011111", 2)));
// B Y R
// 876543218765432187654321
通过观察如果可以针对当前等级对所有三个套装进行同花顺，则可以进一步提高几乎完成组的速度，那么这始终是最佳选择。这大大减少了递归次数，因为可以一次跳过九张卡片。在为等级1和等级2尝试3种之后，应立即添加此检查：
if (suit == 0) { // try straight flush for all suits
var flush3 = 460551 << rank - 2; // 460551 = rank 1, 2 and 3 of all suits
if ((cards & flush3) == flush3) {
max = rank * 30 + 90;
if (rank > 2) max += max_score(cards - flush3, 0, rank - 3);
return max;
}
}