Gin Rummy - Algorithm for determining optimal melding - algorithm

Question

A similar question to this has been asked here, but in my question, rather than being restricted to melds of size 3, melds can be any size.
In Gin Rummy, for any particular set of cards, cards can be grouped into either sets or runs. A set is a group of 3 or more cards that are all of the same rank (2-D, 2-C, 2-H or 7-D, 7-C, 7-H, 7-S). A run is a group of 3 or more cards with consecutive ranks and identical suits (A-D, 2-D, 3-C or 7-C, 8-C, 9-C, 10-C, J-C). Cards not belonging to a group are called "deadwood".
The goal of my algorithm is to find the optimal melding for a particular set of cards, which is one that minimizes the sum of the values of all the deadwood (The values of number cards are their associated numbers, the value of the ace is 1, and the value of face cards is 10.).
My original attempt at an algorithm worked on the assumption that for any run and group of sets that conflicted, either the run would exist or the group of sets would exist. Under this assumption, the algorithm could just calculate the sum of the values of the run and the sum of the values of all the sets, and keep whichever was greater. For example, if we had the groups
[2-D, 3-D, 4-D], [2-D, 2-C, 2-H], and [4-D, 4-H, 4-S]. The sum of the run's value would be 2 + 3 + 4 = 9, and the sum of the all the set's values would be 2 + 2 + 2 + 4 + 4 + 4 = 18. In this case, this would mean the two sets would be kept for the optimal melding and the run would not be used (3-D would be deadwood).
This assumption worked for groups of size 3, but fails with larger groups. For example, consider the following two groups:
[4-D, 5-D, 6-D, 7-D], [7-D, 7-H, 7-S]
The optimal grouping for this ends up being [4-D, 5-D, 6-D] and [7-D, 7-H, 7-S]. The conflicting set and part of the run is kept. I'm not sure how to create an algorithm, that isn't just brute force.
Any help or ideas would be appreciated.
EDIT
I'm realizing that my original algorithm doesn't even work for size 3 melds. In the case of the following groups:
[4-D, 5-D, 6-D], [4-C, 5-C, 6-C], [6-D, 6-C, 6-S]
The algorithm would look at the two runs individually, and conclude that they should be removed in favor of the set, but the optimal solution would be to keep both runs and remove the set.
Still looking for help in creating an algorithm that works in all edge cases.

Answer 1

My previous answer got deleted as I didn't really provide an explanation, and simply provided a link to a script with an algorithm for this problem. I realize why that isn't fit for an answer on stack overflow now. Here's my attempt at a complete answer.
The algorithm I show here is based on the approach found here: https://gist.github.com/yalue/2622575. The solution is a backtracking search as Paul Hankin suggested above.
The algorithm creates an object called MeldNode:
class MeldNode {
Cards cards;
MeldNode* parent;
double value;
MeldNode(Cards cards, MeldNode* parent) : cards(cards), parent(parent) {
value = sum of values of cards;
if (parent is not null){
value += parent->value;
}
}
}
Here value is equal to the sum of the card values of the cards provided and the value of the parent.
A function cleanMeldGroup is created which, given an array of melds and a meld, will return an array of melds with only melds that don't conflict with the given meld.
Melds cleanMeldGroup(Melds melds, Cards meldAvoid) {
Melds cleanMelds;
for (Cards meld : melds) {
bool clean = true;
for (Card cardA : meld) {
for (Card cardB : meldAvoid) {
if (cardA == cardB) {
clean = false;
}
}
}
if (clean) {
cleanMelds.push(meld);
}
}
return cleanMelds;
}
Next, a function getBestNode is created, which uses backtracking to find a meld node containing the data for the optimal melding combination.
MeldNode* getBestNode(Melds melds, MeldNode* rootNode) {
MeldNode* best = rootNode;
for (Meld meld : melds) {
MeldNode* node = new MeldNode(meld, rootNode);
MeldNode* newTree = getBestNode(cleanMeldGroup(melds, meld), node);
if (best is null || newTree->value > best->value){
best = newTree;
}
}
}
Note that as this is written now, this would result in memory leaks in c++. If necessary, take measures to free memory when the data has been used (You could free the memory of Nodes that aren't part of the best tree in this function, and then free the memory of Nodes that are part of the best tree after you use them).
Finally, the optimal melding can be determined as follows using the getOptimalMelding function.
Melds getOptimalMelding(Cards hand) {
Sort hand by rank and then by suit;
Melds possibleMelds;
// Find all possible runs
int runLength = 1;
for (int i = 0; i < hand.size(); i++) {
if (hand[i].suit == hand[i - 1].suit && hand[i].rank == hand[i - 1].rank + 1) {
runLength++;
} else {
if (runLength >= 3) {
for (int size = 3; size <= runLength; size++) {
for (int start = 0; start <= runLength - size; start++) {
Cards run;
for (int j = i - runLength + start; j < i - runLength + start + s; j++) {
run.push(hand[j]);
}
possibleMelds.push(run);
}
}
}
runLength = 1;
}
}
if (runLength >= 3) {
for (int size = 3; size <= runLength; size++) {
for (int start = 0; start <= runLength - size; start++) {
Cards run;
for (int j = i - runLength + start; j < i - runLength + start + s; j++) {
run.push(hand[j]);
}
possibleMelds.push(run);
}
}
}
// Find all possible sets
for (int i = 1; i <= 13; i++) {
Cards set;
for (Card card : hand) {
if (card.rank == i) {
set.push(card);
}
}
if (set.size() >= 3) {
possibleMelds.push(set);
}
if (set.size() == 4) {
for (Card card : set) {
Cards subset;
for (Card add : set) {
if (add != card) {
subset.push(add);
}
}
possibleMelds.push(subset);
}
}
}
// Find Optimal Melding Combination
MeldNode* bestNode = getBestNode(possibleMelds, null);
Melds optimalMelds;
while (bestNode is not null){
optimalMelds.push(bestNode.cards);
bestNode = bestNode->parent;
}
return optimalMelds;
Note that possibleMelds contains all possible melds of all sizes. For example, for the hand [2-D, 3-D, 4-D, 5-D, 5-H, 5-S, 5-C, 10-S, 9-C, 8-H], possibleMelds would contain the following groups:
[2-D, 3-D, 4-D],
[3-D, 4-D, 5-D],
[2-D, 3-D, 4-D, 5-D],
[5-D, 5-H, 5-S, 5-C],
[5-H, 5-S, 5-C],
[5-D, 5-S, 5-C],
[5-D, 5-H, 5-C],
[5-D, 5-H, 5-S]