Coding Question for SDE Positon - Related to DP - data-structures

Question

My friend gave a test in which he got this question. I tried my best to solve this problem but couldn't get much far,
Can someone provide the approach to solve this question?
Problem statement
Input?Output Test Cases

Answer 1

Lets define a function f(i,j) that gives the maximum value of taken diamonds from the first i boxes (1,2....i) where we picked the diamond j from box i.
Then the answer to your problem will be max(f(n,j)) where j=1,2,...bn where bn is the number of diamonds in box n.
For each box we need to try to pick one diamond and we try to maximize the value with picking one of non similar color diamonds from the previous box, so the formula would be:
f(i,j) = Vj + max(f(i-1,k)) // diamond k should not have the same color as diamond j
To calculate max(f(i-1,k)) in an efficient way you can keep track of the maximum 2 values of function f(i,j) for each box i:
max1 = f(i,j1)
max2 = f(i,j2)
here is a psuedo code:
max1 = -1;
max2 = -1;
for (int i = 1; i <= N; i++) {
for (int j = 1; j <= diamonds_of_box_i; j++) {
f[i][j] = -1;
if (max1.color != diamond[j].color && max1 != -1)
f[i][j] = max(f[i][j], max1) + Vj;
if (max2.color != diamond[j].color && max2 != -1)
f[i][j] = max(f[i][j], max2) + Vj;
}
max1 = max2 = -1;
for (int j = 1; j <= diamonds_of_box_i; j++) {
if (f[i][j] > max1) {
max2 = max1;
max1 = f[i][j];
}
else if (f[i][j] > max2) {
max2 = f[i][j];
}
}
}
for (int j = 1; j < diamonds_of_box_n; j++){
if (f[n][j] > res)
res = f[n][j];
}
print(res);

Answer 2

Your first step is to determine if a given set of inputs provides any solution at all. One way it would be impossible to have a solution is if two consecutive boxes each only have one color. It uses numbers, but I like to think in colors, so say a box is red, the next box is also red. That's no good, condition fails.
But it gets worse - what if a box is red, the next box is red and orange, and the NEXT box is just orange. Well, if you have to take red in that first box, then you must take orange in the second box. But you also must take orange in the third box!
You start by constructing a matrix of these boxes and keeping track of what gems are inside them, and which of those gems are eligible to be chosen. Iterating over the matrix, you take each box with only one color and exclude the boxes on either side from having that color. Then iterate again, since now some boxes will have only one color now (like the red/orange in the previous example). If you have a box with no valid choices, then you're done. There may be some edge case I'm missing, but hopefully you get the idea now.
This concept is actually very similar to how sudoku solvers work - consider looking at those for inspiration.
If every box has a valid choice, then it's time to optimize for value. I would start by just identifying the largest value diamond in each box. Obviously you want to pick this the most often as possible. A naive algorithm might just iterate over the boxes in a single pass, picking the highest gem, or second highest gem if the highest gem was taken by the last box. A more advanced algorithm might look ahead at the next few boxes (or the entire rest of the set?) to determine which is the best combination. There's probably some more advanced way to handle it that I'm not seeing, but again, this should point some interested party in the right direction.