我觉得动态规划主要有两点:
1. 当前这个点要与不要
2. 由小推向大(也就是所谓子问题),以空间换时间。
01背包
例:有5个物品,w = [2,2,6,5,4],v = [6,3,5,4,6],背包的容量为10。
1. 一个物品一个物品的慢慢放
2. 拿到一个物品到底是放还是不放
当前物品不放,则价值为上一次放的情况;如果放了,则价值为把前i-1个物品放入(当前容量-这个物品容量)的价值加当前物品的价值。显然,谁大要谁。
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | |
---|---|---|---|---|---|---|---|---|---|---|---|
0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
1 | 0 | 0 | 6 | 6 | 6 | 6 | 6 | 6 | 6 | 6 | 6 |
2 | 0 | 0 | ? | ||||||||
3 | 0 | 0 | |||||||||
4 | 0 | 0 | |||||||||
5 | 0 | 0 |
初始化:i个物品装入容量0的背包中,价值肯定0;0个物品放入容量j的背包,价值也是0 。
dp[1][?]处放第一个物品,放不下,价值是放0物品时得0;放进去价值是6;
dp[2][?]处放第二个物品,放不下,价值和上一行的一样;?处放得下,放,价值为前(2-1)个物品放入(2-2)容量中,得,0+3 = 3;不放,就是上一次的6,;所以?处不放新物品。
以此类推。。。
最后放到第5个物品,便能得到最大价值。
/**
* @param c : 表示背包容量
* @param n : 表示商品个数
* @param w : 表示商品重量
* @param p : 表示商品价值
*
*/
public static int KnapSack(int c,int n,int w[],int p[]){
//c[i][m] 表示前i件物品放入容量为m的背包时的最大价值
int[][] dp = new int[n+1][c+1];
for(int i=0;i<n+1;i++){
dp[i][0] = 0;
}
for(int j=0;j<c+1;j++){
dp[0][j] = 0;
}
for(int i=1;i<n+1;i++){
for(int j=1;j<c+1;j++){
if(w[i-1] <= j){ //放得下,谁大要谁
dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-w[i-1]]+p[i-1]);
}else{ //放不下,就是上一次的情况
dp[i][j] = dp[i-1][j];
}
}
}
return dp[n][c];
}
最长公共子序列
例:给定两个字符串 “abcbdb”和 “acbbabdbb”,返回这两个字符串的最长公共子序列的长度。
1. 从字符串开头慢慢比
2. 当前字符相等了,公共长度则为上一次的加1;不等了,要么不要字符1要么不要字符2,显然,谁的结果长要谁。
“” | a | c | b | b | a | b | d | b | b | ||
---|---|---|---|---|---|---|---|---|---|---|---|
0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | ||
“” | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |
a | 1 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
b | 2 | 0 | 1 | ? | |||||||
c | 3 | 0 | 1 | ||||||||
b | 4 | 0 | 1 | ||||||||
d | 5 | 0 | 1 | ||||||||
b | 6 | 0 | 1 |
初始化:有一方为空,公共长度都是0;
dp[1][?]处第一个字符的比较结果,a==a,则长度为:上一次(即左上对角线)[0][0]+1 = 1; a != c,不要a(即上一行)则长度为0;不要c(即左一列)则长度为1。所以公共长度为1
dp[2][?]处第二个字符的比较结果,b != a,不要b(即上一行),长度为1;不要a(即左一列)长度为0 。所以公共长度为1 。
以此类推。。。
最后字符比较完,便能得到最长结果。
public int longestCommonSubsequence(String str1, String str2) {
if (str1 == null || str2 == null || str1.length() == 0 || str2.length() == 0)
return 0;
int[][] dp = new int[str1.length() + 1][str2.length() + 1];
for (int i = 1; i <= str1.length(); i++) {
for (int j = 1; j <= str2.length(); j++) {
if (str1.charAt(i - 1) == str2.charAt(j - 1)) //当前相等
dp[i][j] = dp[i - 1][j - 1] + 1; //上一次加这一个
else //不等
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]); //谁长要谁
}
}
return dp[str1.length()][str2.length()];
}
编辑距离
例:给你两个单词 word1 = “horse”和word2 = “ros”,请你计算出将 word1 转换成 word2 所使用的最少操作数 。
1. 从字符串开头慢慢比
2. 当前字符相等了,则编辑距离和上一次一样;不等了,则进行如下的三种编辑,显然,谁小要谁。
你可以对一个单词进行如下三种操作:
- 插入一个字符
- 删除一个字符
- 替换一个字符
“” | h | o | r | s | e | ||
---|---|---|---|---|---|---|---|
0 | 1 | 2 | 3 | 4 | 5 | ||
“” | 0 | 0 | 1 | 2 | 3 | 4 | 5 |
r | 1 | 1 | 1 | ? | |||
o | 2 | 2 | 1 | ||||
s | 3 | 3 | 1 |
初始化:一个字符编辑成一个字符串,这个简单。
dp[1][?]处第一个字符的编辑距离,r != h,则进行编辑:不要r(即上一行)(对于另一个字符串而言就是加上h,效果一样)则编辑距离为1+1=2;不要h(即左一列)则编辑距离为1+1=2。替换,编辑距离为上一次加1,即0+1 = 1 。所以编辑距离为1,替换一次就行。
以此类推。。。
最后字符比较完,便能得到最小编辑距离。
public int minDistance(String word1, String word2) {
int n1 = word1.length();
int n2 = word2.length();
int[][] dp = new int[n1 + 1][n2 + 1];
// 第一行
for (int j = 1; j <= n2; j++) dp[0][j] = dp[0][j - 1] + 1;
// 第一列
for (int i = 1; i <= n1; i++) dp[i][0] = dp[i - 1][0] + 1;
for (int i = 1; i <= n1; i++) {
for (int j = 1; j <= n2; j++) {
if (word1.charAt(i - 1) == word2.charAt(j - 1))
dp[i][j] = dp[i - 1][j - 1];
else{
int min = Math.min(dp[i][j - 1], dp[i - 1][j]); //删或者说加
dp[i][j] = Math.min(dp[i - 1][j - 1], min ) + 1; //替换
}
}
}
return dp[n1][n2];
}
打家劫舍
例:如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警。房屋存放金额[1,2,3,1],计算不触动警报装置的情况下 ,能够偷窃到的最高金额。
1. 一间一间慢慢偷
2. 当前房屋到底偷还是不偷。
当前房屋偷了,则价值上上一次的价值加这一次的价值;如果不偷,则价值为上一次的价值。显然,谁大要谁。
public int rob(int[] nums) {
int len = nums.length;
if(len == 0) return 0;
int[] dp = new int[len + 1];
dp[0] = 0;
dp[1] = nums[0];
for(int i = 2; i <= len; i++) {
dp[i] = Math.max(dp[i-1], dp[i-2] + nums[i-1]);
}
return dp[len];
}
零钱兑换
例:给定不同面额的硬币 coins = [1, 2, 5]和一个总金额 amount = 11。计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额,返回 -1。
1. 一块钱一块钱的慢慢换
2. 当前这个硬币到底要不要。
当前硬币不要,则个数没变化;如果要,则个数变为兑换(要兑换的钱减去当前这个面额)的个数加1。显然,谁小要谁。
public static int coinChange(int[] coins, int amount) {
//dp[i]表示钱数为i时最小硬币数
int dp[] = new int[amount + 1];
//初始化钱数为i时的硬币数
Arrays.fill(dp,amount +1);
dp[0] = 0;
//钱数为0时的最小硬币数也为0
for(int i = 1;i<=amount;i++){
for(int coin : coins){
if(i >= coin){
dp[i] = Math.min(dp[i],dp[i-coin]+1);
}
}
}
return dp[amount]> amount ? -1:dp[amount];
}