I am assuming the formulation from Neal Fultz's answer. I can think of two approaches: binary linear integer programming (hinted at Neal's answer), or dynamic optimization. Based on my quick testing with MATLAB, at least with a randomly generated increment matrix, $N_o=20$ options and $N_n=25$ increments, the dynamic optimization approach seems faster (answer produced in 0.006 seconds with the computer I'm currently using and perhaps rather unoptimized code).
Dynamic Programming
Note that the optimal selections for options $j,\ldots,N_o$ depend only on the number of increments remaining after making selections for options $1,\ldots,j-1$. Hence, the problem follows the optimality principle, and dynamic programming may be used. Start from the last iteration, and compute the optimal policy as a function of remaining increments (taking into account the remaining increments for next step), and iterate this backwards. For the last option, obviously all increments are used.
To work out your example case:
- For the last (3rd) option, all increments are used, and the score as a function of $(0,\ldots,4)$ increments remaining at this step is $(0,0.2,0.2,0.2,0.2,0.2)$.
- 2nd option: If there are no increments remaining, score is 0. If 1 increment, it is better to not use it (score 0.2). If 2 increments, one is used, one left for next round (score 0.3). If 3 increments, two used, one left for next rounds (score 0.311). If 4 increments, 3 used, one left for next rounds (score 0.3111). Thus, at this round, the score of remaining rounds is $(0,0.2,0.3,0.311,0.311)$.
- 1st option: For the first option, we need to only look at the 4 increments remaining -case. The best option is to use 3 increments here, with 1 remaining and score $0.3021+0.2 = 0.5021$.
The optimal strategy can be found by working forward, counting the number of remaining increments and recalling the optimal pick for that remaining number of increments.
Zero-one Integer Programming
Let $x_{ij}$ be a binary variable indicating whether we select the $j$th increment of $i$th option. The optimization problem is
\begin{equation}
\max_x \sum_i^{N_o} \sum_j^{N_i} c_{ij}x_{ij},
\end{equation}
where $c_{ij}$s are the numbers in your increment table as in the question. We have two types of constraints. First, each increment can be picked only if the previous increment is picked with the same option:
\begin{equation}
\forall i\in\{1,\dots,N_o\}, \forall j\in\{2,\ldots,N_i\}: x_{ij}\leq x_{i\,j-1}.
\end{equation}
The second type of constraint is that the we cannot overall select more than $N_i$ increments,
\begin{equation}
\sum_{i=1}^{N_o} \sum_{j=1}^{N_i} x_{ij} \leq N_i.
\end{equation}
Both the objective function and the constraints are linear, wherefore this is a zero-one integer programming problem, for which solution algorithms are implemented in optimization software packages (Branch\&Cut + Simplex for the LP subproblems is one idea I know of). However, at least with MATLABs bintprog, this was slower than the dynamic programming approach with $N_i=25,N_o=20$. However, it is sometimes possible to speed up integer programming problems by improving the problem formulation, the one I presented here is perhaps not optimal, I don't know.
