java - 计算最佳组合

我正在设计一个应用程序，其中我需要从一组肥料中选择，最好的组合，即能够提供给定养分的最小肥料量。
例如，假设我需要供应23g N（氮）和23g P（磷），我有以下两套肥料：
集合1：
肥料n p k（g/100kg）
A 23 0
B 18 46 0
C 46 0 0
集合2：
肥料n p k（g/100kg）
D 23 0
东18 46 0
F_______16__0__0
在步骤1中：
我们可以选择50kg的b肥，获得23g的p肥，选择30kg的c肥，获得所需的n肥总量80kg，而不是选择100kg的a肥。
在步骤2中：
选择100kg的d肥比选择e肥和f肥要好。
现在，我正在尝试一种算法来计算最佳组合。我相信贪婪的做法行不通。所以我试着在三维矩阵上对n，p，k的所有可能的积分值进行动态编程，但这会导致精度的损失。我只有有限的资源。
有人能提出其他方法吗？
我觉得这可能是一个图形问题，但我不知道如何建模。
下面是我为动态编程编写的代码：

void evaluateChoices() {
        dp = new int[MAX + 1][MAX + 1][MAX + 1];
        for(int i = 0; i < MAX; i++) {
            for(int j = 0; j < MAX; j++) {
                for(int k = 0; k < MAX; k++) {
                        if(i == 0 && j == 0 && k == 0) {
                            dp[0][0][0] = 0;
                        }
                        else {
                            considerCurrent(i, j, k);
                        }
                }
            }
        }
    }


void considerCurrent(int i, int j, int k) {
    int minyet = Integer.MAX_VALUE;
    for(int choice = 0; choice < numFertilizers; choice++) {
        fertilizer fertilizerOption = fertilizerChoices[choice];
        int amount;
        if(fertilizerOption.N >= fertilizerOption.K && fertilizerOption.N >= fertilizerOption.P) {
            amount = (100 / fertilizerOption.N) * i;
            if(amount == 0) {                               // required amount is amount of N i.e i
                continue;
            }
            if(((j - (fertilizerOption.P / 100)) * amount) >= 0 && ((k - (fertilizerOption.K / 100)) * amount) >= 0) {
                int jIndex = (j - ((fertilizerOption.P / 100) * amount));
                int kIndex = (k - ((fertilizerOption.K / 100) * amount));
                if(dp[0][jIndex][kIndex] + amount < minyet) {
                    dp[i][j][k] = dp[0][jIndex][kIndex] + amount;
                }
            }
        }
        else if(fertilizerOption.P >= fertilizerOption.K && fertilizerOption.P >= fertilizerOption.N) {
            amount = (100 / fertilizerOption.P) * j;
            if(amount == 0) {                               // required amount is amount of P i.e j
                continue;
            }
            if(((i - (fertilizerOption.N / 100)) * amount) >= 0 && ((k - (fertilizerOption.K / 100)) * amount) >= 0) {
                int iIndex = (i - ((fertilizerOption.N / 100) * amount));
                int kIndex = (k - ((fertilizerOption.K / 100) * amount));
                if(dp[iIndex][0][kIndex] + amount < minyet) {
                    dp[i][j][k] = dp[iIndex][0][kIndex] + amount;
                }
            }
        }
        else {
            amount = (100 / fertilizerOption.K) * k;
            if(amount == 0) {                               // required amount is amount of K i.e k
                continue;
            }
            if((i - ((fertilizerOption.N / 100) * amount)) >= 0 && (j - ((fertilizerOption.P / 100) * amount)) >= 0) {
                int iIndex = ((i - (fertilizerOption.N / 100) * amount));
                int jIndex = ((j - (fertilizerOption.P / 100)  * amount));
                if(dp[iIndex][jIndex][0] + amount < minyet) {
                    dp[i][j][k] = dp[iIndex][jIndex][0] + amount;
                }
            }
        }
    }
}

这里i，j，k是n，p，k的值。
我面临的问题是，当我计算指数时，例如：

int jIndex = (j - ((fertilizerOption.P / 100) * amount));

我正在失去精度，我无法真正帮助它，因为我正在映射到数组索引。

最佳答案

这叫做线性程序。你在做线性优化。
您可以使用Simplex Algorithm来解决此类任务。