My code:
public class Solution {
private int min = -1;
public int coinChange(int[] coins, int amount) {
if (coins == null || coins.length == 0 || amount < 0)
return -1;
else if (amount == 0)
return 0;
Arrays.sort(coins);
int ret = helper(coins, amount, coins.length - 1, 0);
return (ret == Integer.MAX_VALUE ? -1 : ret);
}
private int helper(int[] coins, int amount, int end, int counter) {
if (amount == 0)
return counter;
else if (amount < 0)
return Integer.MAX_VALUE;
else if (end < 0)
return Integer.MAX_VALUE;
int contain = helper(coins, amount - coins[end], end, counter + 1); // contain coins[end]
int miss = helper(coins, amount, end - 1, counter); // miss coins[end]
return Math.min(contain, miss);
}
}
这个解法是超时的。
采用了 backtracing 的思想，复杂度达到了惊人的 O(2 ^ n)
其实这道题目原型不就是 combination 吗？
combination 要求你返回所有组合，而这个，是让你返回所有组合中size最小的。
看了答案后，正确解法如下，
My code:
public class Solution {
public int coinChange(int[] coins, int amount) {
if (coins == null || coins.length == 0 || amount < 0)
return 0;
if (amount == 0)
return 0;
int[][] dp = new int[amount + 1][coins.length]; // for getting amount i, using coins[] from 0 to j, how many coins
for (int i = 0; i < dp[0].length; i++)
dp[0][i] = 0;
for (int i = 1; i < dp.length; i++) {
for (int j = 0; j < dp[0].length; j++) {
int contain = -1;
if (i - coins[j] >= 0)
contain = (dp[i - coins[j]][j] == -1 ? -1 : dp[i - coins[j]][j] + 1);
int miss = -1;
if (j >= 1)
miss = dp[i][j - 1];
if (contain == -1 && miss == -1)
dp[i][j] = -1;
else if (contain == -1 || miss == -1)
dp[i][j] = (contain == -1 ? miss : contain);
else
dp[i][j] = Math.min(contain, miss);
}
}
return dp[dp.length - 1][dp[0].length - 1];
}
}
采用backtracking 的方法，为什么复杂度会那么高？
因为里面有大量的重复的case，一次次地被再次访问。
而使用了 dp， 将已经完成的结果全部存起来，下次要用的时候，直接访问，就可以了。不用再次推导。这也是dp的意义。
**
将已经获得的结果存起来，下次使用就不需要再花时间求了。避免了重复时间。
**
参考网页：
http://www.geeksforgeeks.org/dynamic-programming-set-7-coin-change/
另外，这道题目要求的是最小coins组合，返回个数。
也可以求，达到target的所有组合个数。这样, dp[i][j] 的含义，就是达到i，由coins[0] - [j]，有多少种组合个数。 dp[0][j] = 1
也可以，再进一步，做成 combination.
Combination 复杂度是 O(2 ^ n)
而用这个dp，思路如下，
使用一个HashMap, key = i * row + j , which should be unique
value = its set for target.
那么，dp[i][j]时，
首先，
如果 dp[ i - coins[j] ] [j] = 0, 那么 (i, j) -> empty set
如果 dp[ i - coins[j] ] [j] > 0, 那么dp[i][j] = dp[ i - coins[j] ] [j] + 1,
然后，取出( ( i - coins[j] ) , j) 对应的set，深拷贝一份，插入 coins[ i ],
将整体插入到 (i, j) -> set 的HashMap 中。
我觉得是可行的。但可能会出现重复问题。
dp是个很大的问题，最近的理解在逐步加深。
去除掉重复情况，类似于一个HashMap
另外，HashSet， contains的复杂度，最坏情况可能是O(n)
HashSet 的底层是由 HashMap 实现的。
Anyway, Good luck, Richardo!
My code:
public class Solution {
public int coinChange(int[] coins, int amount) {
if (coins == null || coins.length == 0) {
return -1;
}
if (amount == 0) {
return 0;
}
Arrays.sort(coins);
int[] dp = new int[amount + 1];
for (int i = 0; i < coins.length; i++) {
if (coins[i] <= amount) {
dp[coins[i]] = 1;
}
}
for (int i = 1; i <= amount; i++) {
if (dp[i] != 0) {
continue;
}
else {
int j = coins.length - 1;
int base = Integer.MAX_VALUE;
for (; j >= 0; j--) {
if (coins[j] > i) {
continue;
}
else if (dp[i - coins[j]] == 0) {
continue;
}
else {
base = Math.min(base, 1 + dp[i - coins[j]]);
}
}
dp[i] = (base == Integer.MAX_VALUE ? 0 : base);
}
}
return dp[amount] == 0 ? -1 : dp[amount];
}
}
不知道为什么之前会用 二维DP来做？
这次做，直接就想到了一唯DP，并且写了出来，虽然提交了好几次。
这道题目和 perfect squares 很相似，都是用几个给定的数，来凑这个数，求最小的次数。
我的思路是，对于不能凑出来的，就让他的值保持0，
比如，
我们要凑一个 i
我们有 coins[],
那么 就
拿coins里面的一个个面值来试，
如果 dp[i - coins[i]] == 0, 那么就代表不能被凑出来，那么就换下一个面值。
如果可以被凑出来，求出最小的那个值。
dp[i] 表示的是， 凑钱到i需要的最少的个数。
O(amount * coins.length）
Anyway, Good luck, Richardo! -- 08/18/2016