Question

具体来说，问题是：
给定面额数组coins[]，每个硬币limits[]的限额数组和数量amount，返回需要的最小硬币数量，以获得{{1} }，或者如果不可能返回null。此外，在数组amount中填写解决方案中使用的每种硬币的编号。

这是我的解决方案：

change

但是它通常无法正常工作。

我的问题是例如：

public static int? Dynamic(int amount, int[] coins, int[] limits, out int[] change)
    {
        int[] minCoins = new int[amount + 1];
        int[,] coinsUsedToAmount = new int[coins.Length, amount + 1];

        minCoins[0] = 1;
        for (int j = 0; j < amount; ++j)
        {
            if (minCoins[j] > 0)
            {
                for (int i = 0; i < coins.Length; ++i)
                {
                    if (coinsUsedToAmount[i, j] < limits[i])
                    {
                        int currAmount = j + coins[i];
                        if (currAmount <= amount)
                        {
                            if (minCoins[currAmount] == 0 || minCoins[currAmount] > minCoins[j] + 1)
                            {
                                minCoins[currAmount] = minCoins[j] + 1;

                                for (int k = 0; k < coins.Length; ++k) 
                                {
                                    coinsUsedToAmount[k, currAmount] = coinsUsedToAmount[k, j];
                                }
                                coinsUsedToAmount[i, currAmount] += 1;
                            }
                        }
                    }
                }
            }
        }

        if (minCoins[amount] == 0)
        {
            change = null;
            return null;
        }

        change = new int[coins.Length];
        for(int i = 0; i < coins.Length; ++i)
        {
            change[i] = coinsUsedToAmount[i, amount];
        }

        return minCoins[amount] - 1;
    }

最佳解决方案是：

amount = 141, 
coins = new int[] { 2, 137, 65, 35, 30, 9, 123, 81, 71 }                                                                                  
limits = new int[] { 1, 1, 1, 1, 1, 1, 1, 1, 1 }

我的算法给出的结果为null。换句话说，它失败了，每当在某种程度上，我将不得不使用比可能的情况少的最优解决方案，然后，最后，我不需要硬币。
在此示例中，我的算法给出：
change = new int[] { 1, 0, 1, 1, 1, 1, 0, 0, 0 } = 2（9 + 123），
但这应该是minCoins[132] = 4（2 + 65 + 35 + 30），因为这样我就可以使用 9 并具有 141 。

我已经回到这个问题了几周了，但仍然无法解决:(我确实在该站点和其他站点上看到了许多解决类似问题的解决方案，但是没有一个对我有帮助。

Answer 1

我的朋友帮助我解决了这个问题。想法是，我们从amount到0，并尝试尽可能使用每种硬币的名义价格-这样一来，我们一开始就不会使用某些硬币，然后无法将它们用作金额。

public static int? Dynamic(int amount, int[] coins, int[] limits, out int[] change)
{
        int[][] coinsUsed = new int[amount + 1][];
        for (int i = 0; i <= amount; ++i)
        {
            coinsUsed[i] = new int[coins.Length];
        }

        int[] minCoins = new int[amount + 1];
        for (int i = 1; i <= amount; ++i)
        {
            minCoins[i] = int.MaxValue - 1;
        }

        int[] limitsCopy = new int[limits.Length];
        limits.CopyTo(limitsCopy, 0);

        for (int i = 0; i < coins.Length; ++i)
        {
            while (limitsCopy[i] > 0)
            {
                for (int j = amount; j >= 0; --j)
                {
                    int currAmount = j + coins[i];
                    if (currAmount <= amount)
                    {
                        if (minCoins[currAmount] > minCoins[j] + 1)
                        {
                            minCoins[currAmount] = minCoins[j] + 1;

                            coinsUsed[j].CopyTo(coinsUsed[currAmount], 0);
                            coinsUsed[currAmount][i] += 1;
                        }
                    }
                }

                limitsCopy[i] -= 1;
            }
        }

        if (minCoins[amount] == int.MaxValue - 1)
        {
            change = null;
            return null;
        }

        change = coinsUsed[amount];
        return minCoins[amount];
}

硬币数量有限的最小硬币找零问题

1 个答案: