Java 基于列表动态创建循环链

我正在练习Java，我试图创建一个程序来计算一个数字可以用一定数量的除法器进行除法的方法

例如：

100是数字，除数是50,20,5。可能的划分是什么

答案是：

Amount of 50 : 0, Amount of 20 : 0, Amount of 10 : 10
Amount of 50 : 0, Amount of 20 : 1, Amount of 10 : 8
Amount of 50 : 0, Amount of 20 : 2, Amount of 10 : 6
Amount of 50 : 0, Amount of 20 : 3, Amount of 10 : 4
Amount of 50 : 0, Amount of 20 : 4, Amount of 10 : 2
Amount of 50 : 1, Amount of 20 : 0, Amount of 10 : 5
Amount of 50 : 1, Amount of 20 : 1, Amount of 10 : 3
Amount of 50 : 1, Amount of 20 : 2, Amount of 10 : 1
Amount of 50 : 2

我编写了一个代码，要求用户输入一个金额和3个除数。现在，我试图找出是否有一种方法可以根据用户的需要为尽可能多的分隔符动态创建代码。代码在某种程度上是非常重复的，并且有一种特定的模式可以添加另一个分隔符，但是我不知道如何实现对代码的这种动态更改

我想到的第一个代码如下：

public class Test2 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("Insert the amount:");
        int amount = scanner.nextInt();
        List<Integer> dividers = new ArrayList<>();
        System.out.println("Insert the first divider:");
        int tempDivider = scanner.nextInt();
        if (!dividers.contains(tempDivider)) {
            dividers.add(tempDivider);
        }

        while (dividers.size()<3) {
                System.out.println("Insert the next divider: (" + (3-dividers.size()) + " more to go)");
                tempDivider = scanner.nextInt();
            if (!dividers.contains(tempDivider)) {
                dividers.add(tempDivider);
            }
        }

        dividers.sort(Collections.reverseOrder());
        System.out.print("Dividers are: ");
        System.out.println(dividers);

        int getal1 = dividers.get(0);
        int getal2 = dividers.get(1);
        int getal3 = dividers.get(2);

        int fiftyAmount = amount / getal1;
        int fiftyRemainder = amount % getal1;
        for (int i = 0; i <= fiftyAmount; i++) {
            int currentFiftyAmount = amount - (getal1 * i);
            int twentyAmount = currentFiftyAmount / getal2;
            int twentyRemainder = currentFiftyAmount % getal2;
            if (twentyAmount == 0) {
                StringBuilder output = new StringBuilder();
                output.append("Amount of " + getal1 + " banknotes: " + i);
                if (fiftyRemainder != 0) output.append(", Remainder: " + fiftyRemainder);
                System.out.println(output);
            } else {
                for (int j = 0; j <= twentyAmount; j++) {
                    int currentTwentyAmount = currentFiftyAmount - (getal2 * j);
                    int tenAmount = currentTwentyAmount / getal3;
                    int tenRemainder = currentTwentyAmount % getal3;
                    if (tenAmount == 0) {
                        StringBuilder output = new StringBuilder();
                        output.append("Amount of " + getal1 + " banknotes: " + i + ", Amount of " + getal2 + " banknotes: " + j);
                        if (tenRemainder != 0) output.append(", Remainder: " + twentyRemainder);
                    } else {
                        StringBuilder output = new StringBuilder();
                        output.append("Amount of " + getal1 + " banknotes: " + i + ", Amount of " + getal2 + " banknotes: " + j +
                                ", Amount of " + getal3 + " banknotes: " + tenAmount);
                        if (tenRemainder != 0) output.append(", Remainder: " + tenRemainder);
                        System.out.println(output);
                    }
                }
            }
        }
    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("Insert the amount:");
        int amount = scanner.nextInt();
        List<Integer> dividers = new ArrayList<>();
        System.out.println("Insert the first divider:");
        dividers.add(scanner.nextInt());

        int divider;
        while (dividers.size()<2) {
            System.out.println("Insert the next divider: (" + (2-dividers.size()) + " more to go)");
            divider = scanner.nextInt();
            if (!dividers.contains(divider)) {
                dividers.add(divider);
            }
        }
        dividers.sort(Collections.reverseOrder());
        System.out.print("Dividers are: ");
        System.out.println(dividers);


        int divided1Amount = amount / dividers.get(0);
        int divided1Remainder = amount % dividers.get(0);
        for (int i = 0; i <= divided1Amount; i++) {
            int currentDivided1Amount = amount - (dividers.get(0) * i);
            int divided2Amount = currentDivided1Amount / dividers.get(1);
            int divided2Remainder = currentDivided1Amount % dividers.get(1);
            if (divided2Amount == 0) {
                StringBuilder output = new StringBuilder();
                output.append(dividers.get(0) + ":" + i);
                if (divided1Remainder != 0) {
                    output.append(", Remainder: " + divided1Remainder);
                }
                System.out.println(output);
            } else {
                StringBuilder output = new StringBuilder();
                output.append(dividers.get(0) + ":" + i + "," + dividers.get(1) + ":" + divided2Amount);
                if (divided2Remainder != 0) {
                    output.append(", Remainder: " + divided2Remainder);
                }
                System.out.println(output);
            }
        }
    }
}

公共类Test2{
公共静态void main（字符串[]args）{
扫描仪=新的扫描仪（System.in）；
System.out.println（“插入金额：”）；
int amount=scanner.nextInt（）；
列表除法器=新的ArrayList（）；
System.out.println（“插入第一个分隔符：”）；
int tempDivider=scanner.nextInt（）；
如果（！dividers.contains（tempDivider））{
添加（临时分隔符）；
}
while（dividers.size（）虽然使用嵌套循环可以很好地接近固定数量的divider，但我建议在一般情况下将解决方案编写为递归函数

这个问题非常适合。我的意思是，这个问题可以分解为更简单的子问题，这样，解决方案自然会通过递归实现。例如，在您将100表示为50、20和10的倍数之和的示例中，发现有三个解决方案都使用一个50：

Amount of 50 : 1, Amount of 20 : 0, Amount of 10 : 5
Amount of 50 : 1, Amount of 20 : 1, Amount of 10 : 3
Amount of 50 : 1, Amount of 20 : 2, Amount of 10 : 1

将此视为解决一个子问题，即找到将值50表示为20和10的倍数（即50等于
20*0+10*5
，
20*1+10*3
和
20*2+10*1
）的方法。因此，您可以从这个意义上划分和解决原始问题

设X为表示的数字（如100），D1、D2、DN为分隔符。以下是可能的轮廓：


如果只有一个除法器，N=1，这很容易：根据D1是否除以X，只有零或一个解


否则，可能的解决方案可能有D1和0，1，…，X/D1之间的任意倍数。因此，做一个循环m1=0，1，…，X/D1，递归地解决具有X'=X-m1*D1的子问题和剩余的除法器D2，…，DN。这个子问题有一个较少的除法器，所以经过足够的递归后，它会减少到N=1的情况



这就解决了问题。不过，请注意，完全递归可能会导致组合大量的子问题需要解决。因此，对于有效的解决方案，最好将以前解决的子问题的解决方案存储在表中，这样工作就不会重复

其他想法：


设Q是所有除数{D1，…，DN}中的最大公约数（GCD）。如果X不能被Q整除，则没有解决方案，在这种情况下，我们可以完全跳过上述递归搜索。例如，无法用除数50、20和10表示X=103。此GCD测试也可以应用于每个子问题，以便一些递归调用可以提前返回


这个问题是一种，更具体地说，它与和弗罗贝尼乌斯数有关，我们正在讨论这个问题


感谢您提供的惊人知识！