Java 通过打印所有可能的方式进行循环硬币兑换

我已尝试打印给出给定数量的所有路径。但是我的代码不能正常工作。我想我在打印所有可能的组合时遗漏了一些要点。比如,

• 如果金额：7且startCoin=25，则程序需要提供： {5,1,1}和{1,1,1,1,1}

你能帮我解决这些问题吗

注意：最好是Java解决方案

class Solution {

      static int[] coinSet = {1,5,10,25};
      static List<List<Integer>> possibleWays = new ArrayList<>();
      static List<Integer> currentWay = new ArrayList<>();

      private static int makeChange(int amount, int startCoin){

        boolean flag = false;
        for(int i =0 ; i < coinSet.length ; i++){
          if(coinSet[i] == startCoin) {
            flag =true;
          }
        }

        if(!flag){
          throw new IllegalArgumentException("startCoin has to be in the specified range");
        }

        int nextCoin = 0;
        switch(startCoin) {
          case 25:
            nextCoin = 10;
            break;

          case 10:
            nextCoin = 5;
            break;

          case 5:
            nextCoin = 1;
            break;

          case 1:
            possibleWays.add(currentWay);
            currentWay = new ArrayList<>();
            return 1;
        }

        int ways = 0;

        for(int count = 0; count * startCoin <= amount; count++){
          ways += makeChange(amount - (count * startCoin),nextCoin);
        }

        return ways;

      }    
      public int calculateNumberOfWays(int amount, int startCoin) throws Exception {
        if (amount == 0) {
          throw new Exception();    }

        return makeChange(amount, startCoin);
      }

      public static void main(String[] args) {

        System.out.println(makeChange(5,25));
        System.out.println(possibleWays);

      }
    }

类解决方案{
静态int[]coinSet={1,5,10,25}；
静态列表可能路径=新建ArrayList（）；
静态列表currentWay=newarraylist（）；
私有静态int makeChange（int amount，int startCoin）{
布尔标志=假；
for（int i=0；i对于（int count=0；count*startCoin，这可以使用回溯来解决，但效率不高，下面是工作的java代码

/**
 * Created by sumit sharma on 3/1/2016.
 */
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

public class Main {
    static int[] coinSet = {1,5,10,25};
    static List<List<Integer>> possibleWays = new ArrayList<>();
    static List<Integer> currentWay = new ArrayList<>();
    public static void main(String[] args) {
        List<Integer> countOfCoins = new ArrayList<>();
        makeChange(7, 0, countOfCoins);
        //System.out.print(possibleWays);
    }

    private static int makeChange(int amount, int startCoinIdx, List<Integer> coinsSoFar) {
        if(startCoinIdx == coinSet.length){
            if(amount == 0){
                possibleWays.add(coinsSoFar);
                System.out.println(coinsSoFar);
            }
            //System.out.println(coinsSoFar);
            return 0;
        }
        for(int count = 0;(count*coinSet[startCoinIdx]) <= amount;count++){
            List<Integer> temp = new ArrayList<>();
            for(int i = 0;i < coinsSoFar.size();i++) temp.add(coinsSoFar.get(i));
            for(int i = 0;i < count;i++) temp.add(coinSet[startCoinIdx]);
            makeChange(amount - (count * coinSet[startCoinIdx]),startCoinIdx+1, temp);
            temp.clear();
        }
        return 0;
    }
}

/**
*sumit sharma于2016年3月1日创建。
*/
导入java.util.ArrayList；
导入java.util.Date；
导入java.util.List；
导入java.util.Random；
公共班机{
静态int[]coinSet={1,5,10,25}；
静态列表可能路径=新建ArrayList（）；
静态列表currentWay=newarraylist（）；
公共静态void main（字符串[]args）{
List countOfcons=new ArrayList（）；
makeChange（7,0，countOfCoins）；
//系统输出打印（可能途径）；
}
私有静态int makeChange（int amount、int startcoindx、List coinsofar）{
if（startCoinIdx==coinSet.length）{
如果（金额=0）{
可能途径。添加（coinsSoFar）；
System.out.println（coinsSoFar）；
}
//System.out.println（coinsSoFar）；
返回0；
}
对于（int count=0；（count*coinSet[startCoinIdx]）这可以使用回溯来解决，但这不是很有效，下面是工作的java代码

/**
 * Created by sumit sharma on 3/1/2016.
 */
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;

public class Main {
    static int[] coinSet = {1,5,10,25};
    static List<List<Integer>> possibleWays = new ArrayList<>();
    static List<Integer> currentWay = new ArrayList<>();
    public static void main(String[] args) {
        List<Integer> countOfCoins = new ArrayList<>();
        makeChange(7, 0, countOfCoins);
        //System.out.print(possibleWays);
    }

    private static int makeChange(int amount, int startCoinIdx, List<Integer> coinsSoFar) {
        if(startCoinIdx == coinSet.length){
            if(amount == 0){
                possibleWays.add(coinsSoFar);
                System.out.println(coinsSoFar);
            }
            //System.out.println(coinsSoFar);
            return 0;
        }
        for(int count = 0;(count*coinSet[startCoinIdx]) <= amount;count++){
            List<Integer> temp = new ArrayList<>();
            for(int i = 0;i < coinsSoFar.size();i++) temp.add(coinsSoFar.get(i));
            for(int i = 0;i < count;i++) temp.add(coinSet[startCoinIdx]);
            makeChange(amount - (count * coinSet[startCoinIdx]),startCoinIdx+1, temp);
            temp.clear();
        }
        return 0;
    }
}

/**
*sumit sharma于2016年3月1日创建。
*/
导入java.util.ArrayList；
导入java.util.Date；
导入java.util.List；
导入java.util.Random；
公共班机{
静态int[]coinSet={1,5,10,25}；
静态列表可能路径=新建ArrayList（）；
静态列表currentWay=newarraylist（）；
公共静态void main（字符串[]args）{
List countOfcons=new ArrayList（）；
makeChange（7,0，countOfCoins）；
//系统输出打印（可能途径）；
}
私有静态int makeChange（int amount、int startcoindx、List coinsofar）{
if（startCoinIdx==coinSet.length）{
如果（金额=0）{
可能途径。添加（coinsSoFar）；
System.out.println（coinsSoFar）；
}
//System.out.println（coinsSoFar）；
返回0；
}
对于（int count=0；（count*coinSet[startCoinIdx]）您好，您可以在这里查看帮助：。这不是java，但它解决了您的问题：）。如果您仍然感到困惑，请研究一下回溯问题。您知道此解决方案的时间复杂度和空间复杂度吗？我猜是O（n！）但我不确定。关于复杂性：你可以用动态规划避免指数运行时间。当你有5这样一个值的所有解时，那么6这样一个值的解是（1的所有解）x（5的所有解）。指数复杂性的含义是什么？我现在试图了解上述代码的时间复杂性是什么？您好，您可以在这里查看帮助：。它不是java，但它解决了您的问题：）。如果您仍然感到困惑，请研究一下回溯问题。您知道此解决方案的时间复杂性和空间复杂性是什么吗？我猜是O（n！）但我不确定。关于复杂性：你可以用动态规划避免指数运行时间。当你有5这样一个值的所有解时，那么6这样一个值的解是（1的所有解）x（5的所有解）.指数复杂度的含义是什么？我现在试图了解上述代码的时间复杂度是什么？正如@marco13所建议的，动态规划解决方案也可能更有效，但这会增加所需的内存量或空间复杂度。还请注意，DP解决方案不是多项式，相反，它是我们所称的伪多项式，因为它取决于特定输入所需的内存量。正如@marco13所建议的，也可以使用动态规划解决方案，这将更加有效，但这将增加所需的内存量或空间复杂度。还请注意，DP解决方案不是多项式，instead它是我们所谓的伪多项式，因为它取决于特定输入所需的内存量。