爪哇2博客
爪哇2博客

爪哇中的硬币找零问题

如果您想练习数据结构和算法程序,可以通过 100多种数据结构和算法程序.

在这篇文章中,我们将看到有关Java中的硬币更改问题的信息。


问题

给定要支付的金额和要使用的货币。每种货币都有无限的供应量,可以组合使用给定数量的货币。
Print the number of ways by which the 量 可以支付.

输入:
货币= {2,3,4}
量 = 8

输出值:
2 2 2 2
2 2 4
2 3 3
4, 4,
我们可以使用给定货币付款的方式有:4

由于我们在谈论组合,因此,付款顺序并不重要,即[2,3,3],[3,2,3],[3,3,2]所有涉及相同频率货币的方式将被视为一种方法。


递归方法:

在这种方法中,我们将进行循环调用,以循环方式将所有货币一一减去。

    • we will subtract the 货币 on the current 在dex from the 量 to be 已付 and make the recursive call 对于 the 剩余的 量 to be 已付.
    • 我们保留一个字符串,该字符串跟踪到目前为止已完成的所有付款,并且无论何时进行任何呼叫,我们都将字符串中的已支付货币串联起来。
    • 一旦我们到达要支付的金额为零的点,这便成为我们的基本情况,我们将打印到目前为止已完成的支付字符串并返回一,因为这是我们可以支付所需金额的一种方式。
    • 如果要支付的剩余金额变为负数,这意味着我们没有完美的硬币组合来完美地增加要支付的金额,因此这不是一种支付方式,因此我们从这种基本情况中返回零。
    • 在进行通话时,我们需要确保不使用索引比当前索引低的货币付款,因为这将导致我们不希望的组合重复。因此,每当我们在循环中进行调用时,都将使用当前货币索引(而不是第0个索引)来初始化循环变量。
    • As at every stage of the 量 to be 已付, we are making {number of 货币 –当前索引}通话次数,说 n.
      And the 在itial 量 to be 已付 = x,
      那么该算法最差的时间复杂度是 ^.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
     
    动态编程;
     
    进口 爪哇.实用程序.扫描器;
     
    上市 找零 {
     
    上市 静态的 虚空 主要([] args) {
     
    扫描器 scn = 扫描器(系统.);
    整型[] 货币 = 整型[scn.nextInt()];
     
    对于 (整型 i = 0; i < 货币.长度; i++) {
    货币[i] = scn.nextInt();
    }
     
    整型 = scn.nextInt();
     
    系统..打印(
    “我们可以使用给定货币支付的方式有: +
                                 零钱(0, , 货币, ));
     
    }
     
    上市 静态的 整型 零钱(整型 , 整型 剩余的, 整型[] 货币,
                                       已付) {
    如果 (剩余的 == 0) {
    / *
    * this means the 量 to be 已付 可以支付
    *  仅使用给定的货币。
    * /
    系统..打印(已付);
    / *
    *因为这是付款方式之一,因此它
    *将为自己贡献+1种方式
    * /
    返回 1;
    }
    如果 (剩余的 < 0) {
    / *
    * 如果 the 剩余的 量 to be 已付 is negative,
    *这表示我们已支付的硬币确实
    * not 加 upto the 量 to be 已付, hence it is
    *不是付款方式之一。
    * /
    返回 0;
    }
     
    整型 资源 = 0;
    对于 (整型 i = ; i < 货币.长度; i++) {
     
    / *
    *我们必须从当前索引开始循环,因为
    *如果我们再次遍历所有货币
    *然后将使用的方式重复
    * to pay the 量.
    * /
    资源 + = 零钱(i, 剩余的 - 货币[i], 货币,
                        已付 + 整数.toString(货币[i]) + ”,“);
     
    }
     
    返回 资源;
     
    }
     
    }
     

    考虑以下用于测试用例的递归树:Amount = 8,货币= [2,4]

    硬币找零

    高效的方法:

    考虑上面的递归树,

    • 我们可以清楚地看到重复的调用,其中一次又一次地计算出数量= 4和数量= 2的结果,也就是说,大多数子问题存在重叠,这增加了算法的复杂性。
    • 同样,我们可以看到较大子问题的结果是按事后顺序计算的,也就是说,在获得较小子问题的结果后,较大子问题的结果是所有子项的总和,即较小子问题。
    • 因为这个问题具有动态规划的两个属性,即重叠子问题和最优子结构。因此,我们将采用动态编程方法来降低解决方案的最差时间复杂度。

    算法:

    • We make an 数组 to store the 资源ult of smaller subproblems, say dp, of 尺寸 量 + 1,
      因为在第一个索引处,我们存储支付金额= i的方式的数量,因此对于具有索引的‘amount’ we need to make an array of 量 + 1 尺寸.
    • 我们基本上为每种货币处理此数组,也就是说,对于每种货币,我们在dp数组上运行一个循环以计算支付金额的总方式,其中货币数量=当前货币指数+ 1。
    • 了解该算法需要了解的一点是,
      如果 current 量 – current 货币 可以支付 使用 这种货币 然后, current 量 也可以支付, 那是, 如果(dp [amt– 货币]) >= 1 then (dp[amt]++)
    • 因此,对于每种金额的每种货币,我们只需要检查金额货币是否大于可以支付的金额即可。如果否,那么也无法使用当前货币集支付此金额。
    • Now as 对于 every 货币 we are processing every 量 ranging from 0 to given 量,
      因此,这种方法最糟糕的时间复杂度是 O(金额*货币数)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
     
    动态编程;
     
    进口 爪哇.实用程序.数组列表;
    进口 爪哇.实用程序.扫描器;
     
    上市 找零 {
     
    上市 静态的 虚空 主要([] args) {
     
    扫描器 scn = 扫描器(系统.);
    整型[] 货币 = 整型[scn.nextInt()];
     
    对于 (整型 i = 0; i < 货币.长度; i++) {
    货币[i] = scn.nextInt();
    }
     
    整型 = scn.nextInt();
     
    硬币兑换(, 货币);
    }
     
     
    上市 静态的 虚空 硬币兑换(整型 , 整型[] 货币) {
    / *
    * dp数组将包含方式“ i”的数量
    * 量 可以支付 使用 the given 货币,
    * therefore, we made dp of 尺寸 量+1 to have
    * an 在dex = 量.
    * /
    整型[] dp = 整型[ + 1];
    数组列表<>[] 付款方式 = 数组列表[+1];
    对于(整型 i=0;i<付款方式.长度; i++)
    {
    付款方式[i] = 数组列表<>();
    }
     
    / *
    * positive basecase, when we have 剩余的 量 = 0,
    *这意味着我们找到了一种付款方式
    * 在itial 量.
    * /
    dp[0] = 1;
     
    对于 (整型 货币 : 货币) {
    对于 (整型 AMT = 1; AMT < dp.长度; AMT++) {
    如果(AMT-货币 >=0 && dp[AMT - 货币] != 0)
    {
    dp[AMT] + =1;
            / *   我们制作了一个由字符串数组列表组成的数组
    * store all the ways of paying the current 量,
             *  therefore, the 付款方式 of current 量 =
    *  串联的(金额-货币)付款
    *  使用当前货币* /
    付款方式[AMT].(付款方式[AMT-货币].尺寸()>0?
          (付款方式[AMT-货币].得到(付款方式[AMT-货币].尺寸()-1) + 货币 + )
           : 整数.toString(货币) + );
    }
    }
    }
    / * number of ways of paying given 量 = dp[amount]*/
    系统..打印(dp[] + “ \ n” + 付款方式[]);
     
    }
     
    }
     

    那’关于Java中的硬币更改问题。

分享这个

相关文章

  • 11月29日

    超过100个Java编码面试问题

    我一直在发布有关各种主题的数据结构和编码面试问题,例如数组,队列,堆栈,二叉树,LinkedList,字符串,数字,ArrayList等。因此,我将合并一个Java编码面试问题列表以创建索引发布。每当我添加新的Java [时,我都会继续添加指向此帖子的链接[…]

  • 4月18日

    到达最后一个索引的最小跳转数

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何找到到达上一个索引的最小跳转数。问题给定一个正整数数组A(可能为零),每个索引表示[…]

  • 3月28日

    对0、1和2的数组进行排序

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何对0、1和2s的数组进行排序。我们已经看到了有关对数组中的0s和1s进行排序的文章。问题给定一个包含零的数组,[…]

  • 3月04

    通过跳转检查是否有可能到达给定数组的末尾

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。问题给定一个具有正整数作为元素的数组,该数组指示可以从数组中任何位置进行跳转的最大长度。检查是否可以[…]

  • 2月17日

    检查数组元素是否连续

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将看到如何检查数组元素是否连续。问题给定一个数组,我们需要检查数组是否包含连续的元素。例如:输入:array [] = {5,3,4,[…]

  • 2月04日

    O(Sqrt(height))中的K元树的LCA

    如果您想练习数据结构和算法程序,可以阅读100多种数据结构和算法程序。在这篇文章中,我们将了解如何在O(Sqrt(height))中找到K元树的最低公共祖先。我们已经看到了如何在O(n)复杂度中找到n元树的LCA。给定[…]

发表评论

您的电子邮件地址不会被公开。 必需的地方已做标记 *

订阅我们的新闻

获取质量教程到您的收件箱。现在订阅。


成为朋友

©2020 爪哇2博客