LeetCode - 322. 零钱兑换(递归、记忆化搜索、动态规划、广度优先)
题目:
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。
你可以认为每种硬币的数量是无限的。
示例 1:
输入:coins = [1, 2, 5], amount = 11
输出:3
解释:11 = 5 + 5 + 1
示例 2:
输入:coins = [2], amount = 3
输出:-1
示例 3:
输入:coins = [1], amount = 0
输出:0
示例 4:
输入:coins = [1], amount = 1
输出:1
示例 5:
输入:coins = [1], amount = 2
输出:2
提示:
1 <= coins.length <= 12
1 <= coins[i] <= 231 - 1
0 <= amount <= 104
解题思路:
-
这种找路径,找方法的题一般可以使用回溯法来解决,回溯法也可以说是树形图法,解题的时候使用类似于树状图的结构,使用 自顶而下 的方法。
-
而在回溯法中,如果含有很多的重复的计算的时候,就可以使用记忆化的搜索,将可能出现的重复计算大状态使用一个数组来保存其值,在进行重复的计算的时候,就可以直接的调用数组中的值,较少了不必要的递归。
-
使用了记忆化搜索后,一般还可以进行优化,在记忆化搜索的基础上,变成 自底而上 的动态规划。
方法一: 递归
使用递归的关键是知道递归函数是用来干什么的,从宏观的角度去理解递归。
直接使用递归超出时间限制
class Solution {
int res = Integer.MAX_VALUE;
public int coinChange(int[] coins, int amount) {
if(coins.length == 0){
return -1;
}
findWay(coins,amount,0);
// 如果没有任何一种硬币组合能组成总金额,返回 -1。
if(res == Integer.MAX_VALUE){
return -1;
}
return res;
}
public void findWay(int[] coins,int amount,int count){
if(amount < 0){
return;
}
if(amount == 0){
res = Math.min(res,count);
}
for(int i = 0;i < coins.length;i++){
findWay(coins,amount-coins[i],count+1);
}
}
}
方法二:记忆化搜索
class Solution {
int[] memo;
public int coinChange(int[] coins, int amount) {
if(coins.length == 0){
return -1;
}
memo = new int[amount];
return findWay(coins,amount);
}
// memo[n] 表示钱币n可以被换取的最少的硬币数,不能换取就为-1
// findWay函数的目的是为了找到 amount数量的零钱可以兑换的最少硬币数量,返回其值int
public int findWay(int[] coins,int amount){
if(amount < 0){
return -1;
}
if(amount == 0){
return 0;
}
// 记忆化的处理,memo[n]用赋予了值,就不用继续下面的循环
// 直接的返回memo[n] 的最优值
if(memo[amount-1] != 0){
return memo[amount-1];
}
int min = Integer.MAX_VALUE;
for(int i = 0;i < coins.length;i++){
int res = findWay(coins,amount-coins[i]);
if(res >= 0 && res < min){
min = res + 1; // 加1,是为了加上得到res结果的那个步骤中,兑换的一个硬币
}
}
memo[amount-1] = (min == Integer.MAX_VALUE ? -1 : min);
return memo[amount-1];
}
}
方法三:动态规划
上面的记忆化搜索是先从 memo[amonut-1]开始,从上到下
动态规划从 memo[0] 开始,从下到上
class Solution {
public int coinChange(int[] coins, int amount) {
// 自底向上的动态规划
if(coins.length == 0){
return -1;
}
// memo[n]的值: 表示的凑成总金额为n所需的最少的硬币个数
int[] memo = new int[amount+1];
memo[0] = 0;
for(int i = 1; i <= amount;i++){
int min = Integer.MAX_VALUE;
for(int j = 0;j < coins.length;j++){
if(i - coins[j] >= 0 && memo[i-coins[j]] < min){
min = memo[i-coins[j]] + 1;
}
}
// memo[i] = (min == Integer.MAX_VALUE ? Integer.MAX_VALUE : min);
memo[i] = min;
}
return memo[amount] == Integer.MAX_VALUE ? -1 : memo[amount];
}
}
另一种实现
memo[i]有两种实现的方式,去两者的最小值
包含当前的 coins[i],那么剩余钱就是 i-coins[i],这种操作要兑换的硬币数是 memo[i-coins[j]] + 1
不包含,要兑换的硬币数是 memo[i]
class Solution {
public int coinChange(int[] coins, int amount) {
// 自底向上的动态规划
if(coins.length == 0){
return -1;
}
// memo[n]的值: 表示的凑成总金额为n所需的最少的硬币个数
int[] memo = new int[amount+1];
// 给memo赋初值,最多的硬币数就是全部使用面值1的硬币进行换
// amount + 1 是不可能达到的换取数量,于是使用其进行填充
Arrays.fill(memo,amount+1);
memo[0] = 0;
for(int i = 1; i <= amount;i++){
for(int j = 0;j < coins.length;j++){
if(i - coins[j] >= 0){
// memo[i]有两种实现的方式,
// 一种是包含当前的coins[i],那么剩余钱就是 i-coins[i],这种操作要兑换的硬币数是 memo[i-coins[j]] + 1
// 另一种就是不包含,要兑换的硬币数是memo[i]
memo[i] = Math.min(memo[i],memo[i-coins[j]] + 1);
}
}
}
return memo[amount] == (amount+1) ? -1 : memo[amount];
}
}
方法四:广度优先遍历
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
public class Solution {
public int coinChange(int[] coins, int amount) {
if (amount == 0) {
return 0;
}
Queue<Integer> queue = new LinkedList<>();
boolean[] visited = new boolean[amount + 1];
visited[amount] = true;
queue.offer(amount);
// 排序是为了加快广度优先遍历过程中,对硬币面值的遍历,起到剪枝的效果
Arrays.sort(coins);
int step = 1;
while (!queue.isEmpty()) {
int size = queue.size();
for (int i = 0; i < size; i++) {
Integer head = queue.poll();
for (int coin : coins) {
int next = head - coin;
// 只要遇到 0,就找到了一个最短路径
if (next == 0) {
return step;
}
if (next < 0) {
// 由于 coins 升序排序,后面的面值会越来越大,剪枝
break;
}
if (!visited[next]) {
queue.offer(next);
// 添加到队列的时候,就应该立即设置为 true
// 否则还会发生重复访问
visited[next] = true;
}
}
}
step++;
}
// 进入队列的顶点都出队,都没有看到 0 ,就表示凑不出当前面值
return -1;
}
}