最少硬币使用算法 Java

Question

我被硬币面额的问题困住了。

我试图找出构成 5.70 美元（或 570 美分）的最少硬币数量。例如，如果硬币数组是 {100,5,2,5,1}（100 x 10c 硬币、5 x 20c、2 x 50c、5 x $1 和 1 x $2 硬币），那么结果应该是 { 0,1,1,3,1} 目前硬币阵列将包含相同面额（$2、$1、50c、20c、10c）

public static int[] makeChange(int change, int[] coins) {

    // while you have coins of that denomination left and the total
    // remaining amount exceeds that denomination, take a coin of that
    // denomination (i.e add it to your result array, subtract it from the
    // number of available coins, and update the total remainder). –

    for(int i= 0; i< coins.length; i++){
    while (coins[i] > 0) {

        if (coins[i] > 0 & change - 200 >= 0) {

            coins[4] = coins[4]--;
            change = change - 200;

        } else 

        if (coins[i] > 0 & change - 100 >= 0) {

            coins[3] = coins[3]--;
            change = change - 100;

        } else

        if (coins[i] > 0 & change - 50 >= 0) {

            coins[2] = coins[2]--;
            change = change - 50;

        } else

        if (coins[i] > 0 & change - 20 >= 0) {

            coins[1] = coins[1]--;
            change = change - 20;

        } else

        if (coins[i] > 0 & change - 10 >= 0) {

            coins[0] = coins[0]--;
            change = change - 10;

        }
    }

    }
    return coins;

}

我被困在如何从硬币数组中扣除值并返回它。

编辑：新代码

Answer 1

蛮力解决方案是尝试使用最高面额的硬币的可用数量（当你用完时停止或金额将变为负数），并为其中的每一个递归解决剩余金额的较短列表排除该面额，并选择其中的最小值。如果基本情况是 1c 问题总是可以解决的，基本情况是return n 否则是n/d0（d0 代表最低面额），但必须注意在不均匀时返回较大的值可分割，因此优化可以选择不同的分支。记忆是可能的，并通过剩余金额和下一个尝试的面额进行参数化。所以备忘录表的大小是O(n*d)，其中n是起始金额，d是面额数量。

所以问题可以在伪多项式时间内解决。

Answer 2

wikipedia link 没有详细说明如何确定像您这样的贪心算法是否有效。此CS StackExchange question 中链接了更好的参考。本质上，如果硬币系统是规范，贪心算法将提供最佳解决方案。那么，[1, 2, 5, 10, 20] 是规范的吗？ （使用 10 美分作为单位，因此序列从 1 开始）

根据this article，5 币系统是非-规范的当且仅当它完全满足以下条件之一：

• [1, c2, c3] 不规范（[1, 2, 5] 为假）
• 不能写成 [1, 2, c3, c3+1, 2*c3]（对于 [1, 2, 5, 10, 20] 为真）
• greedyAnswerSize((k+1) * c4) > k+1 with k*c4

因此，由于贪心算法不会提供最佳答案（即使它提供了，我怀疑它是否适用于有限的硬币），你应该尝试动态编程或一些开明的回溯：

import java.util.HashSet;
import java.util.PriorityQueue;

public class Main {

    public static class Answer implements Comparable<Answer> {
        public static final int coins[] = {1, 2, 5, 10, 20};

        private int availableCoins[] = new int[coins.length];
        private int totalAvailable;
        private int totalRemaining;
        private int coinsUsed;

        public Answer(int availableCoins[], int totalRemaining) {
            for (int i=0; i<coins.length; i++) {
                this.availableCoins[i] = availableCoins[i];
                totalAvailable += coins[i] * availableCoins[i];
            }
            this.totalRemaining = totalRemaining;
        }

        public boolean hasCoin(int coinIndex) { 
            return availableCoins[coinIndex] > 0; 
        }

        public boolean isPossibleBest(Answer oldBest) {
            boolean r = totalRemaining >= 0
                && totalAvailable >= totalRemaining
                && (oldBest == null || oldBest.coinsUsed > coinsUsed);
            return r;
        }

        public boolean isAnswer() {
            return totalRemaining == 0;
        }

        public Answer useCoin(int coinIndex) {
            Answer a = new Answer(availableCoins, totalRemaining - coins[coinIndex]);
            a.availableCoins[coinIndex]--;
            a.totalAvailable = totalAvailable - coins[coinIndex];
            a.coinsUsed = coinsUsed+1;
            return a;
        }

        public int getCoinsUsed() {
            return coinsUsed;
        }

        @Override
        public String toString() {
            StringBuilder sb = new StringBuilder("{");
            for (int c : availableCoins) sb.append(c + ",");            
            sb.setCharAt(sb.length()-1, '}');
            return sb.toString();
        }

        // try to be greedy first
        @Override
        public int compareTo(Answer a) {
            int r = totalRemaining - a.totalRemaining;
            return (r==0) ? coinsUsed - a.coinsUsed : r;
        }
    }        

    // returns an minimal set of coins to solve
    public static int makeChange(int change, int[] availableCoins) {
        PriorityQueue<Answer> queue = new PriorityQueue<Answer>();
        queue.add(new Answer(availableCoins, change));
        HashSet<String> known = new HashSet<String>();
        Answer best = null;
        int expansions = 0;
        while ( ! queue.isEmpty()) {
            Answer current = queue.remove();            
            expansions ++;
            String s = current.toString();
            if (current.isPossibleBest(best) && ! known.contains(s)) {
                known.add(s);
                if (current.isAnswer()) {
                    best = current;
                } else {
                    for (int i=0; i<Answer.coins.length; i++) {
                        if (current.hasCoin(i)) {
                            queue.add(current.useCoin(i));
                        }
                    }
                }
            }
        }
        // debug
        System.out.println("After " + expansions + " expansions");
        return (best != null) ? best.getCoinsUsed() : -1;
    }

    public static void main(String[] args) {
        for (int i=0; i<100; i++) {
            System.out.println("Solving for " + i + ":"
                + makeChange(i, new int[]{100,5,2,5,1}));
        }
    }
}

Answer 3

你走错方向了。该程序不会为您提供最佳解决方案。要获得最佳解决方案，请使用此处实施和讨论的动态算法。请访问以下几个链接：

1. link 1
2. link 2
3. link 3