Skip to content

Commit dbb679d

Browse files
committed
review-9_1
1 parent c38e15c commit dbb679d

12 files changed

Lines changed: 185 additions & 145 deletions

File tree

‎src/main/java/com/chen/algorithm/znn/backtrack/ZeroOneBag.java‎

Lines changed: 23 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,14 @@
11
package com.chen.algorithm.znn.backtrack;
22

3+
import org.junit.Test;
4+
35
/**
6+
* https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/0-1-bei-bao-wen-ti-xiang-jie-zhen-dui-ben-ti-de-yo/
7+
* 作为「0-1 背包问题」,它的特点是:「每个数只能用一次」。解决的基本思路是:物品一个一个选,容量也一点一点增加去考虑,这一点是「动态规划」的思想,特别重要。
8+
* 在实际生活中,我们也是这样做的,一个一个地尝试把候选物品放入「背包」,通过比较得出一个物品要不要拿走。
9+
*
10+
* 具体做法是:画一个 len 行,target + 1 列的表格。这里 len 是物品的个数,target 是背包的容量。len 行表示一个一个物品考虑,target + 1多出来的那 1 列,表示背包容量从 0 开始考虑。很多时候,我们需要考虑这个容量为 0 的数值。
11+
*
412
* 我们有一个背包,背包总的承载重量是Wkg。现在我们有n个物品,每个物品的重量不等,并且不可分割。我们现在期望选择几件物品,
513
* 装载到背包中。在不超过背包所能装载重量的前提下,如何让背包中物品的总重量最大?
614
*
@@ -76,21 +84,25 @@ public void bag2(int i, int cw) {
7684
* @param n n:物品个数(0-5)
7785
* @param w w:背包可承载重量(0-9)
7886
* @return
87+
* 状态定义:第一维n表示放了几个物品,第二维w表示放或放入物品后,背包里的总重量
88+
* 状态转移方程:
89+
* 思路:物品一个一个尝试,容量一点一点尝试,每个物品分类讨论的标准是:选与不选。
7990
*/
8091
public int knapsack(int[] weight, int n, int w) {
92+
// 状态定义:第一维表示放了几个物品,第二维表示放或放入物品后,背包里的总重量
8193
boolean[][] states = new boolean[n][w + 1]; //默认值false
8294
states[0][0] = true; //初始化,第一行的数据要特殊处理,可以利用哨兵优化
8395
states[0][weight[0]] = true;
8496

8597
for (int i = 1; i < n; i++) { // 动态规划状态转移
8698
for (int j = 0; j <= w; j++) { // 不把第i个物品放入背包
87-
if (states[i - 1][j] == true) {
88-
states[i][j] = true;
99+
if (states[i - 1][j]) {
100+
states[i][j] = states[i - 1][j];
89101
}
90102
}
91-
for (int j = 0; j + weight[i] <= w; i++) { //把第i个物品放入背包
92-
if (states[i - 1][j] == true) {
93-
states[i - 1][j + weight[i]] = true;
103+
for (int j = 0; j + weight[i] <= w; j++) { //把第i个物品放入背包
104+
if (states[i - 1][j]) {
105+
states[i][j + weight[i]] = true;
94106
}
95107
}
96108
}
@@ -101,4 +113,10 @@ public int knapsack(int[] weight, int n, int w) {
101113
}
102114
return 0;
103115
}
116+
117+
@Test
118+
public void test() {
119+
int cw = knapsack(items, n, w);
120+
System.out.println(cw);
121+
}
104122
}

‎src/main/java/com/chen/algorithm/znn/dynamic/test121/Solution.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,7 +20,7 @@
2020
*
2121
* @Auther: zhunn
2222
* @Date: 2020/11/3 19:59
23-
* @Description: 买卖股票的最佳时机:双指针法
23+
* @Description: 买卖股票的最佳时机:双指针法 买入算一笔交易
2424
* 121(最多买卖一次)、122(贪心,最多买卖多次,不限次)、123(最多买卖两次)、188(最多买卖K次)、309(可以买卖多次,有冷冻期)、714(可以买卖多次,一次买卖含一次手续费)
2525
* 注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)
2626
*/

‎src/main/java/com/chen/algorithm/znn/dynamic/test123/Solution.java‎

Lines changed: 72 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -26,74 +26,107 @@
2626
*
2727
* @Auther: zhunn
2828
* @Date: 2020/11/3 21:06
29-
* @Description: 买卖股票的最佳时机 III:1-动态规划-优化空间;2-动态规划
29+
* @Description: 买卖股票的最佳时机 III:1-动态规划;2-动态规划-优化空间
3030
*/
3131
public class Solution {
3232

3333
/**
34-
* 1-动态规划-优化空间
35-
* (由于今天只参考了昨天的状态,所以直接去掉第一维度不会影响状态转移的正确性)
34+
* 1-动态规划 dp[i][j][k]: i 表示第几天(0-n),j表示交易了几次(0,1,2),k表示是否持股(0-不持股,1-持股)
3635
*
3736
* @param prices
38-
* @return dp[i][j][k]: i 表示第几天(0-n),j表示交易了几次(0,1,2),k表示是否持股(0-不持股,1-持股)
39-
* 此题可以用dp[j][k] 即可
37+
* @return
4038
*/
4139
public int maxProfit(int[] prices) {
42-
if (prices == null || prices.length < 2) {
40+
int len = prices.length;
41+
if (len < 2) {
4342
return 0;
4443
}
45-
int[][] dp = new int[3][2];
46-
dp[0][0] = 0;
47-
dp[1][1] = -prices[0];
48-
dp[2][1] = Integer.MIN_VALUE; // 还没发生的交易,持股的时候应该初始化为负无穷
4944

50-
for (int i = 1; i < prices.length; i++) {
51-
dp[1][1] = Math.max(-prices[i], dp[1][1]);
52-
dp[1][0] = Math.max(dp[1][1] + prices[i], dp[1][0]);
53-
dp[2][1] = Math.max(dp[1][0] - prices[i], dp[2][1]);
54-
dp[2][0] = Math.max(dp[2][1] + prices[i], dp[2][0]);
45+
// 第 2 维的 0 没有意义,1 表示交易进行了 1 次,2 表示交易进行了 2 次
46+
// 为了使得第 2 维的数值 1 和 2 有意义,这里将第 2 维的长度设置为 3
47+
int[][][] dp = new int[len][3][2];
48+
49+
// 理解如下初始化
50+
// 第 3 维规定了必须持股,因此是 -prices[0]
51+
dp[0][1][1] = -prices[0];
52+
// 还没发生的交易,持股的时候应该初始化为负无穷
53+
dp[0][2][1] = Integer.MIN_VALUE;
54+
55+
for (int i = 1; i < len; i++) {
56+
// 转移顺序先持股,再卖出
57+
dp[i][1][1] = Math.max(dp[i - 1][1][1], dp[i - 1][0][0] - prices[i]);
58+
dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][1][1] + prices[i]);
59+
dp[i][2][1] = Math.max(dp[i - 1][2][1], dp[i - 1][1][0] - prices[i]);
60+
dp[i][2][0] = Math.max(dp[i - 1][2][0], dp[i - 1][2][1] + prices[i]);
5561
}
56-
return Math.max(dp[1][0], dp[2][0]);
62+
return Math.max(dp[len - 1][1][0], dp[len - 1][2][0]);
5763
}
5864

5965
/**
60-
* 2-动态规划
66+
* 2-动态规划-优化空间
67+
* (由于今天只参考了昨天的状态,所以直接去掉第一维度不会影响状态转移的正确性)
6168
*
6269
* @param prices
63-
* @return
70+
* @return dp[i][j][k]: i 表示第几天(0-n),j表示交易了几次(0,1,2),k表示是否持股(0-不持股,1-持股)
71+
* 此题可以用dp[j][k] 即可
6472
*/
6573
public int maxProfit2(int[] prices) {
66-
if (prices == null || prices.length == 0) {
74+
if (prices == null || prices.length < 2) {
6775
return 0;
6876
}
69-
// dp[i][j] ,表示 [0, i] 区间里,状态为 j 的最大收益
70-
// j = 0:什么都不操作
71-
// j = 1:第 1 次买入一支股票
72-
// j = 2:第 1 次卖出一支股票
73-
// j = 3:第 2 次买入一支股票
74-
// j = 4:第 2 次卖出一支股票
75-
76-
int n = prices.length;
77-
int[][] dp = new int[n][5];
77+
int[][] dp = new int[3][2];
7878
dp[0][0] = 0;
79-
dp[0][1] = -prices[0];
80-
for (int i = 0; i < n; i++) {
81-
dp[i][3] = Integer.MIN_VALUE;
82-
}
79+
dp[1][1] = -prices[0];
80+
dp[2][1] = Integer.MIN_VALUE; // 还没发生的交易,持股的时候应该初始化为负无穷
8381

84-
for (int i = 1; i < n; i++) {
85-
dp[i][0] = 0;
86-
dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
87-
dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
88-
dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
89-
dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
82+
for (int i = 1; i < prices.length; i++) {
83+
dp[1][1] = Math.max(dp[1][1], dp[0][0] - prices[i]);
84+
dp[1][0] = Math.max(dp[1][0], dp[1][1] + prices[i]);
85+
dp[2][1] = Math.max(dp[2][1], dp[1][0] - prices[i]);
86+
dp[2][0] = Math.max(dp[2][0], dp[2][1] + prices[i]);
9087
}
91-
return Math.max(Math.max(dp[n - 1][0], dp[n - 1][2]), dp[n - 1][4]);
88+
return Math.max(dp[1][0], dp[2][0]);
9289
}
9390

91+
///**
92+
// * 3-动态规划
93+
// *
94+
// * @param
95+
// * @return
96+
// */
97+
//public int maxProfit3(int[] prices) {
98+
// if (prices == null || prices.length == 0) {
99+
// return 0;
100+
// }
101+
// // dp[i][j] ,表示 [0, i] 区间里,状态为 j 的最大收益
102+
// // j = 0:什么都不操作
103+
// // j = 1:第 1 次买入一支股票
104+
// // j = 2:第 1 次卖出一支股票
105+
// // j = 3:第 2 次买入一支股票
106+
// // j = 4:第 2 次卖出一支股票
107+
//
108+
// int n = prices.length;
109+
// int[][] dp = new int[n][5];
110+
// dp[0][0] = 0;
111+
// dp[0][1] = -prices[0];
112+
// for (int i = 0; i < n; i++) {
113+
// dp[i][3] = Integer.MIN_VALUE;
114+
// }
115+
//
116+
// for (int i = 1; i < n; i++) {
117+
// dp[i][0] = 0;
118+
// dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
119+
// dp[i][2] = Math.max(dp[i - 1][2], dp[i - 1][1] + prices[i]);
120+
// dp[i][3] = Math.max(dp[i - 1][3], dp[i - 1][2] - prices[i]);
121+
// dp[i][4] = Math.max(dp[i - 1][4], dp[i - 1][3] + prices[i]);
122+
// }
123+
// return Math.max(Math.max(dp[n - 1][0], dp[n - 1][2]), dp[n - 1][4]);
124+
//}
125+
94126
@Test
95127
public void test() {
96128
int[] prices = {3, 3, 5, 0, 0, 3, 1, 4};
129+
System.out.println(maxProfit(prices));
97130
System.out.println(maxProfit2(prices));
98131
}
99132
}

‎src/main/java/com/chen/algorithm/znn/dynamic/test188/Solution.java‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -152,6 +152,7 @@ public int maxProfit2(int[] prices, int k) {
152152
@Test
153153
public void test() {
154154
int[] prices = {3, 2, 6, 5, 0, 3};
155+
System.out.println(maxProfit(prices, 2));
155156
System.out.println(maxProfit2(prices, 2));
156157
}
157158
}

‎src/main/java/com/chen/algorithm/znn/dynamic/test309/Solution.java‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@
1616
*
1717
* @Auther: zhunn
1818
* @Date: 2020/11/3 22:03
19-
* @Description: 最佳买卖股票时机含冷冻期:1-动态规划;2-动态规划-优化空间
19+
* @Description: 最佳买卖股票时机含冷冻期:1-动态规划(推荐);2-动态规划-优化空间
2020
*/
2121
public class Solution {
2222

@@ -84,5 +84,6 @@ public int maxProfit2(int[] prices) {
8484
public void test() {
8585
int[] prices = {1, 2, 3, 0, 2};
8686
System.out.println(maxProfit(prices));
87+
System.out.println(maxProfit2(prices));
8788
}
8889
}

‎src/main/java/com/chen/algorithm/znn/dynamic/test322/Solution.java‎

Lines changed: 17 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -35,23 +35,31 @@
3535
*/
3636
public class Solution {
3737

38+
/**
39+
* 动态规划-优化空间(推荐)
40+
*
41+
* @param coins
42+
* @param amount
43+
* @return
44+
*/
3845
public int coinChange(int[] coins, int amount) {
3946
if (coins == null || coins.length == 0) {
47+
if(amount == 0){
48+
return 0;
49+
}
4050
return -1;
4151
}
4252

43-
int max = amount + 1;
44-
int[] dp = new int[amount + 1]; // 给 0 占位
45-
Arrays.fill(dp, max); // 注意:因为要比较的是最小值,这个不可能的值就得赋值成为一个最大值
53+
int[] dp = new int[amount + 1]; // 状态转移方程-凑成amount数值需要的最少硬币数,给 0 占位
54+
Arrays.fill(dp, amount + 1); // 注意:因为要比较的是最小值,这个不可能的值就得赋值成为一个最大值
55+
dp[0] = 0; // 理解 dp[0] = 0 的合理性,单独一枚硬币如果能够凑出面值,符合最优子结构
4656

47-
dp[0] = 0; // 理解 dp[0] = 0 的合理性,单独一枚硬币如果能够凑出面值,符合最优子结构
48-
for (int i = 1; i <= amount; i++) {
49-
for (int j = 0; j < coins.length; j++) {
50-
if (coins[j] <= i) {
51-
dp[i] = Math.min(dp[i], dp[i - coins[j]] + 1);
52-
}
57+
for (int coin : coins) {
58+
for (int i = coin; i <= amount; i++) {
59+
dp[i] = Math.min(dp[i], dp[i - coin] + 1);
5360
}
5461
}
62+
5563
return dp[amount] > amount ? -1 : dp[amount];
5664
}
5765

‎src/main/java/com/chen/algorithm/znn/dynamic/test416/Solution.java‎

Lines changed: 8 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,7 @@
44

55
/**
66
* https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/0-1-bei-bao-wen-ti-xiang-jie-zhen-dui-ben-ti-de-yo/
7+
* https://leetcode-cn.com/problems/partition-equal-subset-sum/solution/fen-ge-deng-he-zi-ji-by-leetcode-solution/
78
* 416. 分割等和子集
89
* 给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集,使得两个子集的元素和相等。
910
* 注意:
@@ -20,7 +21,7 @@
2021
*
2122
* @Auther: zhunn
2223
* @Date: 2020/11/5 18:27
23-
* @Description: 分割等和子集:1-动态规划, 0-1背包问题;2-动态规划-剪枝;3-动态规划-优化空间
24+
* @Description: 分割等和子集:1-动态规划, 0-1背包问题;2-动态规划-剪枝(推荐);3-动态规划-优化空间(推荐2演化到3)
2425
*/
2526
public class Solution {
2627

@@ -54,13 +55,8 @@ public boolean canPartition(int[] nums) {
5455

5556
for (int i = 1; i < len; i++) { //再填表格后面几行
5657
for (int j = 0; j <= target; j++) {
57-
dp[i][j] = dp[i - 1][j]; //直接把结果从上面一行抄下来,然后再修正
58-
if (nums[i] == j) {
59-
dp[i][j] = true;
60-
continue;
61-
}
62-
63-
if (nums[i] < j) {
58+
dp[i][j] = dp[i - 1][j]; //如果不选取nums[i],则dp[i][j]=dp[i−1][j];
59+
if (nums[i] <= j) {
6460
dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
6561
}
6662
}
@@ -99,9 +95,9 @@ public boolean canPartition2(int[] nums) {
9995

10096
for (int i = 1; i < len; i++) {
10197
for (int j = 0; j <= target; j++) {
102-
dp[i][j] = dp[i - 1][j];
98+
dp[i][j] = dp[i - 1][j]; //如果不选取nums[i],则dp[i][j]=dp[i−1][j];
10399
if (nums[i] <= j) {
104-
dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]];
100+
dp[i][j] = dp[i - 1][j] || dp[i - 1][j - nums[i]]; //如果选取nums[i],则dp[i][j]=dp[i−1][j−nums[i]]。选取后j - nums[i]+nums[i]刚好等于j
105101
}
106102

107103
if (dp[i][target]) { // 由于状态转移方程的特殊性,提前结束,可以认为是剪枝操作
@@ -154,6 +150,7 @@ public boolean canPartition3(int[] nums) {
154150
@Test
155151
public void test() {
156152
int[] nums = {1, 5, 11, 5};
157-
System.out.println(canPartition(nums));
153+
System.out.println(canPartition2(nums));
154+
System.out.println(canPartition3(nums));
158155
}
159156
}

‎src/main/java/com/chen/algorithm/znn/dynamic/test474/Solution.java‎

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -24,16 +24,16 @@
2424
*/
2525
public class Solution {
2626

27-
public int findMaxForm(String[] strs, int m, int n) {
28-
int[][] dp = new int[m + 1][n + 1];
29-
for (String s : strs) {
30-
int[] count = countzeroesones(s);
31-
for (int zeroes = m; zeroes >= count[0]; zeroes--)
32-
for (int ones = n; ones >= count[1]; ones--)
33-
dp[zeroes][ones] = Math.max(1 + dp[zeroes - count[0]][ones - count[1]], dp[zeroes][ones]);
34-
}
35-
return dp[m][n];
36-
}
27+
//public int findMaxForm(String[] strs, int m, int n) {
28+
// int[][] dp = new int[m + 1][n + 1];
29+
// for (String s : strs) {
30+
// int[] count = countzeroesones(s);
31+
// for (int zeroes = m; zeroes >= count[0]; zeroes--)
32+
// for (int ones = n; ones >= count[1]; ones--)
33+
// dp[zeroes][ones] = Math.max(1 + dp[zeroes - count[0]][ones - count[1]], dp[zeroes][ones]);
34+
// }
35+
// return dp[m][n];
36+
//}
3737

3838
public int[] countzeroesones(String s) {
3939
int[] cnt = new int[2];
@@ -97,6 +97,7 @@ public int findMaxForm2(String[] strs, int m, int n) {
9797
@Test
9898
public void test() {
9999
String[] strs = {"10", "0001", "111001", "1", "0"};
100+
System.out.println(findMaxForm1(strs, 5, 3));
100101
System.out.println(findMaxForm2(strs, 5, 3));
101102
}
102103
}

0 commit comments

Comments
 (0)