你的法典是一个良好的开端。 改用动态方案拟订办法的通常办法是“自下而上”而不是“从上而下”。 也就是说,如果你的宽恕解决办法使用小X的数值计算出某个特定X的某种东西,那么就算出同一东西从小X开始,并将其列入一个表格。

阁下, 将休养职能改为“智库”。

canMakeChange[0] = True
for X = 1 to (your max value):
   canMakeChange[X] = False
   for i=1 to n:
     if X>=x[i] and canMakeChange[X-x[i]]==True: 
       canMakeChange[X]=True

我的以下解决办法是计算所有解决办法和满足最新最佳解决办法的贪.办法。 如果目前的执行办法已经比紧凑的解决方案大,无法走路。 值得注意的是,最佳表现的派别应处于下降状态。

import java.util.ArrayList;
import java.util.List;

public class CoinDenomination {

    int denomination[] = new int[]{50,33,21,2,1};
    int minCoins=Integer.MAX_VALUE;
    String path;

    class Node{
        public int coinValue;
        public int amtRemaining;
        public int solutionLength;
        public String path="";
        public List<Node> next;

        public String toString() { return "C: "+coinValue+" A: "+amtRemaining+" S:"+solutionLength;}
    }

    public List<Node> build(Node node)
    {
        if(node.amtRemaining==0)
        {
            if (minCoins>node.solutionLength) {
                minCoins=node.solutionLength;
                path=node.path;
            }
            return null;
        }

        if (node.solutionLength==minCoins) return null;
        List<Node> nodes = new ArrayList<Node>();
        for(int deno:denomination)
        {
           if(node.amtRemaining>=deno)
           {
               Node nextNode = new Node();
               nextNode.amtRemaining=node.amtRemaining-deno;
               nextNode.coinValue=deno;
               nextNode.solutionLength=node.solutionLength+1;
               nextNode.path=node.path+"->"+deno;
               System.out.println(node);
               nextNode.next = build(nextNode);
               nodes.add(node);

           }
        }

        return nodes;
    }

    public void start(int value)
    {
        Node root = new Node();
        root.amtRemaining=value;
        root.solutionLength=0;
        root.path="start";
        root.next=build(root);
        System.out.println("Smallest solution of coins count: "+minCoins+" 
Coins: "+path);
    }

    public static void main(String args[])
    {
        CoinDenomination coin = new CoinDenomination();
        coin.start(35);
    }
}

只是为复读解决办法增加一个改观步骤,动态算法是正确的。 下面的例子就是:

cache = {}
def makeChange(amount, coins):
    if (amount,coins) in cache:
        return cache[amount, coins]
    if amount == 0:
        ret = True
    elif not coins:
        ret = False
    elif amount < 0:
        ret = False 
    else:
        ret = makeChange(amount-coins[0], coins) or makeChange(amount, coins[1:])
    cache[amount, coins] = ret
    return ret

当然,你可以使用电解器实现自动消化,从而形成更自然的法典:

def memoize(f):
    cache = {}
    def ret(*args):
        if args not in cache:
            cache[args] = f(*args)
        return cache[args]
    return ret
@memoize
def makeChange(amount, coins):
    if amount == 0:
        return True
    elif not coins:
        return False
    elif amount < 0:
        return False
    return makeChange(amount-coins[0], coins) or makeChange(amount, coins[1:])

注:即便是你所张贴的非动态格式版本,也存在各种最先进的案件。 以上变化略高于您。

本文件非常相关:。

(一) 我的博客@。 更详细情况

public int DP_CoinChange_GetMinimalDemoninations(int[] coins, int sum)
        {
            coins.ThrowIfNull("coins");
            coins.Throw("coins", c => c.Length == 0 || c.Any(ci => ci <= 0));
            sum.Throw("sum", s => s <= 0);
            int[][] DP_Cache = new int[coins.Length + 1][];
            for (int i = 0; i <= coins.Length; i++)
            {
                DP_Cache[i] = new int[sum + 1];
            }
            for(int i = 1;i<=coins.Length;i++)
            {
                for(int s=0;s<=sum;s++)
                {
                    if (coins[i - 1] == s)
                    {
                        //k, we can get to sum using just the current coin
                        //so, assign to 1, no need to process further
                        DP_Cache[i][s] = 1;
                    }
                    else 
                    {
                        //initialize the value withouth the current value
                        int minNoOfCounsWithoutUsingCurrentCoin_I = DP_Cache[i - 1][s];
                        DP_Cache[i][s] = minNoOfCounsWithoutUsingCurrentCoin_I;
                        if ((s > coins[i - 1]) //current coin can particiapte
                            && (DP_Cache[i][s - coins[i - 1]] != 0))
                        {
                            int noOfCoinsUsedIncludingCurrentCoin_I = 
                                DP_Cache[i][s - coins[i - 1]] + 1;
                            if (minNoOfCounsWithoutUsingCurrentCoin_I == 0)
                            {
                                //so far we couldnt identify coins that sums to  s 
                                DP_Cache[i][s] = noOfCoinsUsedIncludingCurrentCoin_I;
                            }
                            else
                            {   
                                int min = this.Min(noOfCoinsUsedIncludingCurrentCoin_I, 
                                    minNoOfCounsWithoutUsingCurrentCoin_I);
                                DP_Cache[i][s] = min;
                            }
                        }
                    }
                }
            }
            return DP_Cache[coins.Length][sum];
        }

在一般情况下,如果元值是任意的,那么所介绍的问题就称为:Knapsack Problem,并且已知属于NP-complete(

采用x 1-2 = 51, xl = 50, x[0] = 1, X = 100。 然后,该算法必须考虑以硬币x2进行变革的可能性,或者从x. 开始作出改变。 The first-ped with national methage, otherwise known as Greedy Algorithm——to wit,“使用的最大硬币少于工作总量”,将不使用病理。 反之,这种算法经历了一种合并的爆炸,使其变成了国家机器。

对于某些特殊硬币价值安排,例如几乎所有实际用途,包括虚构的X[i+1]=2x[i],甚至给出的虚构案例中的O(1)算法非常快,可以确定最佳产出。 这些算法利用了硬币价值的特性。

我不知道有动态的方案拟订办法:一种是利用方案规划模拟所要求的最佳分解决办法。 一般来说,只有能将问题分解成次要问题,才能通过动态的方案拟订解决问题,而这种问题在最佳解决时,可以重新纳入一个可以证明是最佳的解决办法。 也就是说,如果方案管理员不能在数学上证明(“prove”)重新确定问题的最佳分解决办法会导致最佳解决办法,那么就不能适用动态的方案。

经常举出的动态方案拟订的一个例子是采用多种矩阵。 根据矩阵的大小,选择评价A<>>>>。 B。 C (A,,>B,,/b>)或(A,(B,C)>)等两种对应形式之一,即:(,,>B,>>>,,>,,>>,>或(,>,,>,>;,>,>>,>(,,>,>>,>>>>>>>>>>>>。 也就是说,一种方法比另一种方法更为优化(法斯特)。 动态方案规划是一种模拟,它降低了不同方法的计算成本,并按照计算时间(或program)的计算时间表(或program)进行了实际计算。