递归计算硬币支付组合

Question

我正在尝试实现一种递归算法，该算法计算给定金额的所有可能的付款组合。我在递归方面没有太多经验，所以我希望能得到一些帮助。

可用的欧元硬币有：1 美分、2 美分、5 美分、10 美分、20 美分、50 美分、1 欧元、2 欧元。

所以我正在寻找函数的绝对值，它给出给定金额（以美分为单位）的 8 个硬币的线性组合。

所有这些线性组合的绝对值或集合可以拆分为两个不相交的子集，即 M1 是不包含硬币 n 的所有线性组合的集合，而子集 M2 是硬币 n 至少出现一次的子集每个线性组合，这等价于：

为了说明这一点，这里以 5 美分的金额为例，存在 4 种不同的支付选项，即：五枚 1 美分硬币、两枚 2 美分硬币和一枚 1 美分硬币、一枚 2 美分硬币+ 三枚 1 美分硬币，一枚 5 美分硬币。

这是我用 Java 实现的：

public class Coins {


static int[] c = { 1, 2, 5, 10, 20, 50, 100, 200};
static long M1 = 0;


public static long pay ( int m)
{
    int n = c.length;
    long M = pay(m, n);
    return M;
}

private static long pay( int m, int n)
{

    if ( n == 1)
    {   
        return 1;
    }
    if ( m == 0)
        return 1;
    if ( m < 0)
        return 0;
    M1 += pay(m, n - 1) + pay(m - c[n-1], n);
    return M1;
}

public static void main(String[] args) {
    int m = 6;
    long norm = pay(m);
    System.out.println(norm);
}
}

这个实现没有给我正确的解决方案，我不确定为什么它没有或它在做什么。对于m = 6，我尝试使用打印语句来给我中间结果：

count = 1 m= 6 n= 8 M1= 0

count = 3 m= 6 n= 7 M1= 0

count = 5 m= 6 n= 6 M1= 0

count = 7 m= 6 n= 5 M1= 0

count = 9 m= 6 n= 4 M1= 0

count = 11 m= 6 n= 3 M1= 0

count = 13 m= 6 n= 2 M1= 0

count = 15 m= 6 n= 1 M1= 0

count = 16 m= 4 n= 2 M1= 0

count = 18 m= 4 n= 1 M1= 0

count = 19 m= 2 n= 2 M1= 0

count = 21 m= 2 n= 1 M1= 0

count = 22 m= 0 n= 2 M1= 0

count = 23 m= 1 n= 3 M1= 4

count = 25 m= 1 n= 2 M1= 4

count = 27 m= 1 n= 1 M1= 4

count = 28 m= -1 n= 2 M1= 4

count = 29 m= -4 n= 3 M1= 5

count = 30 m= -4 n= 4 M1= 13

count = 31 m= -14 n= 5 M1= 13

count = 32 m= -44 n= 6 M1= 13

count = 33 m= -94 n= 7 M1= 13

count = 34 m= -194 n= 8 M1= 13

现在它实际上确实计数正确，如果你添加m=0 和n=1 的情况，你会得到正确的解决方案，但它会以某种方式得到结果 13。谁能告诉我什么是在这里进行？为什么我的实现结果是 13 而不是 5？

Answer 1

改变

M1 += pay(m, n - 1) + pay(m - c[n-1], n);

到

M1 = pay(m, n - 1) + pay(m - c[n-1], n);

M1 是它下面的 2 个分支的总和。

每次递归调用都会为其子分支计算 M1 并将结果返回给其父分支。