Question

我试图将此问题作为练习来回答：

这里有一组{50,25,10,5,1}美分的硬币。写一个程序，找出通过分组硬币可以创造1美元的方式。

我的解决方案涉及制作一个树，每个边都有一个上面的值。然后每个节点将保存硬币的总和。然后我可以填充这棵树并寻找加起来为100的叶子。所以这是我的代码

class TrieNode
{
public:
    TrieNode(TrieNode* Parent=NULL,int sum=0,TrieNode* FirstChild=NULL,int children=0, bool key =false )
        :pParent(Parent),pChild(FirstChild),isKey(key),Sum(sum),NoChildren(children)
    {
        if(Sum==100)
            isKey=true;
    }
    void SetChildren(int children)
    {
        pChild = new TrieNode[children]();
        NoChildren=children;
    }
    ~TrieNode(void);

    //pointers
    TrieNode* pParent;
    TrieNode* pChild;

    int NoChildren;

    bool isKey;
    int Sum;
};

void Populate(TrieNode* Root, int coins[],int size)
{
    //Set children
    Root->SetChildren(size);

    //add children
    for(int i=0;i<size;i++)
    {
        TrieNode* child  = &Root->pChild[0];
        int c = Root->Sum+coins[i];
        if(c<=100)
        {
            child = new TrieNode(Root,c);

            if(!child->isKey) //recursively populate if not a key
                Populate(child,coins,size);
        }
        else 
            child = NULL;
    }
}

int getNumKeys(TrieNode* Root)
{
    int keys=0;

    if(Root == NULL)
        return 0;

    //increment keys if this is a key
    if(Root->isKey)
        keys++;

    for(int i=0; i<Root->NoChildren;i++)
    {
        keys+= getNumKeys(&Root->pChild[i]);
    }

    return keys;
}

int _tmain(int argc, _TCHAR* argv[])
{
    TrieNode* RootNode = new TrieNode(NULL,0);
    int coins[] = {50,25,10,5,1};
    int size = 5;

    Populate(RootNode,coins,size);
    int combos =  getNumKeys(RootNode);

    printf("%i",combos);

    return 0;
}

问题是树太大了，几秒钟后程序就崩溃了。我在Windows 7，四核，8GB内存上运行它。粗略的计算告诉我应该有足够的记忆。

我的计算不正确吗？操作系统是否限制了我可以访问的内存量？我可以在使用此解决方案的同时修复它吗？

感谢所有反馈。感谢。

EDIT1： 我已经证实上述方法是错误的。通过尝试用一组只有1枚硬币来构建一棵树。 coins [] = {1};

我发现算法仍然失败了。在阅读了Lenik和JoãoMenighin的帖子后我想出了这个解决方案，它将两个Ideas结合在一起，形成递归解决方案采用任何大小的数组

//N is the total the coins have to amount to
int getComobs(int coins[], int size,int N)
{
    //write base cases
    //if array empty | coin value is zero or N is zero
    if(size==0 || coins[0]==0 ||N==0)
        return 0;


    int thisCoin = coins[0];
    int atMost = N / thisCoin ;

    //if only 1 coin denomination
    if(size==1)
    {
        //if all coins fit in N
        if(N%thisCoin==0)
            return 1;
        else
            return 0;
    }


    int combos =0;
    //write recursion
    for(int denomination =0; denomination<atMost;denomination++)
    {
        coins++;//reduce array ptr

        combos+= getComobs(coins, size-1,N-denomination*thisCoin);

        coins--;//increment array ptr
    }

    return combos;
}

感谢所有反馈

Answer 1

树解决方案对于这个问题是完全错误的。这就像捕捉10e6只老虎，然后放弃所有这些只有一只，只因为你需要一只老虎。耗费大量时间和内存 - 99.999％的节点无用，应该首先忽略它们。

这是另一种方法：

注意你不能让一美元包含超过两个50美分
再次注意到你不能让一美元包含超过4个25美分硬币
通知......（你明白了吗？）

然后你的解决方案很简单：

for( int fifty=0; fifty<3; fifty++) {
    for( int quarters=0; quarters<5; quarters++) {
        for( int dimes=0; dimes<11; dimes++) {
            for( int nickels=0; nickels<21; nickels++) {
                int sum = fifty * 50 + quarters * 25 + dimes * 10 + nickels * 5;
                if( sum <= 100 ) counter++;  // here's a combination!!
            }
        }
    }
}

你可能会问，为什么我不对单分硬币采取任何措施？答案很简单，只要sum小于100，剩下的就是1美分。

PS。希望这个解决方案不是太简单=）

Answer 2

好的，这不是一个完整的答案，但可能对你有帮助。您可以尝试执行（我称之为）健全性检查。为static创建一个TrieNode计数器，用于创建的每个节点，并查看它的增长量。如果你做了一些计算，你应该能够判断它是否有一些疯狂的值。

系统可以限制可用内存，但这确实很奇怪。通常，用户/管理员可以出于某些目的设置此类限制。这通常发生在专用的多用户系统中。其他的事情可能是在64位Windows环境中使用32位应用程序。 mem限制将是4GB，但这也很奇怪。任何我认为不受操作系统限制的问题都是这里的问题。

旁注。我希望你确实意识到你有点用这段代码击败了所有面向对象的编程概念：）。

Answer 3

我需要更多时间来分析您的代码，但是现在我可以说这是一个经典的动态编程问题。你可以在这里找到一些有趣的文字：

http://www.algorithmist.com/index.php/Coin_Change

在这里

http://www.ccs.neu.edu/home/jaa/CSG713.04F/Information/Handouts/dyn_prog.pdf

Answer 4

找到解决方案有一种更简单的方法：

#include <iostream>
#include <cstring>
using namespace std;
int main() {
    int w[101];
    memset(w, 0, sizeof(w));
    w[0] = 1;
    int d[] = {1, 5, 10, 25, 50};
    for (int i = 0 ; i != 5 ; i++) {
        for (int k = d[i] ; k <= 100 ; k++) {
            w[k] += w[k-d[i]];
        }
    }
    cout << w[100] << endl;
    return 0;
}

（link to ideone）

这个想法是通过在逐渐增大的面额中添加硬币来逐步建立改变方式的数量。外循环的每次迭代都经过我们已经拥有的结果，并且对于可以使用新添加的硬币构造的每个量，添加了可以构造比当前硬币的值更小的组合的方式的数量。例如，如果当前硬币为5且当前金额为7，则算法会查找2可以构造的方式的数量，并将其添加到方式的数量7可以构建。如果当前硬币为25且当前金额为73，则算法会查找构建48（73-25）的方式的数量，以前面找到的方式数量构建73。最后，w[100]中的数字表示赚1美元的方式（292种方式）。

Answer 5

我确实相信有人必须提供最有效和最简单的可能实施，这是对lenik答案的改进：
记忆：常数
运行时间：将100视为 n ，然后运行时间约为O（n（lg（n）））＆lt; - 我不确定

for(int fifty=0; fifty <= 100; fifty+=50)
    for(int quarters=0; quarters <= (100 - fifty); quarters+=25)
        for(int dimes=0; dimes <= (100 - fifty - quarters); dimes+=10)
            counter += 1 + (100 - fifty - quarters - dimes)/5;

我认为这可以在恒定时间内解决，因为任何序列和都可以用线性公式表示。

Answer 6

问题可能是无限递归。你不是在任何地方递增c而且循环以c <= 100

运行

编辑1：我不确定是否

int c = Root->Sum+coins[i];

实际上超过了100。请验证

编辑2：我错过了正确初始化的总和，并在以下评论中得到纠正。

编辑3： 调试方法 - 您可以做的另一件事是，为这棵树编写打印功能，或者在现有代码中深入进展时在每个级别上打印。添加一个计数器，在总共10次迭代后终止循环。打印件会告诉您是否获得了垃圾值，或者您的c正朝着正确的方向逐渐增加。

程序崩溃，树太大了

6 个答案: