Skip to content
体验新版
项目
组织
正在加载...
登录
切换导航
打开侧边栏
wushizhenking
CS-Notes
提交
500da70e
C
CS-Notes
项目概览
wushizhenking
/
CS-Notes
与 Fork 源项目一致
从无法访问的项目Fork
通知
2
Star
0
Fork
0
代码
文件
提交
分支
Tags
贡献者
分支图
Diff
Issue
0
列表
看板
标记
里程碑
合并请求
0
Wiki
0
Wiki
分析
仓库
DevOps
项目成员
Pages
C
CS-Notes
项目概览
项目概览
详情
发布
仓库
仓库
文件
提交
分支
标签
贡献者
分支图
比较
Issue
0
Issue
0
列表
看板
标记
里程碑
合并请求
0
合并请求
0
Pages
分析
分析
仓库分析
DevOps
Wiki
0
Wiki
成员
成员
收起侧边栏
关闭侧边栏
动态
分支图
创建新Issue
提交
Issue看板
体验新版 GitCode,发现更多精彩内容 >>
提交
500da70e
编写于
4月 03, 2018
作者:
C
CyC2018
浏览文件
操作
浏览文件
下载
电子邮件补丁
差异文件
auto commit
上级
7ca1fcc0
变更
1
隐藏空白更改
内联
并排
Showing
1 changed file
with
30 addition
and
16 deletion
+30
-16
notes/Leetcode 题解.md
notes/Leetcode 题解.md
+30
-16
未找到文件。
notes/Leetcode 题解.md
浏览文件 @
500da70e
...
...
@@ -2052,19 +2052,18 @@ public int lengthOfLCS(int[] nums1, int[] nums2) {
```
java
public
int
knapsack
(
int
W
,
int
N
,
int
[]
weights
,
int
[]
values
)
{
int
[][]
dp
=
new
int
[
N
][
W
];
for
(
int
i
=
W
-
1
;
i
>=
0
;
i
--)
{
dp
[
0
][
i
]
=
i
>
weights
[
0
]
?
values
[
0
]
:
0
;
}
for
(
int
i
=
1
;
i
<
N
;
i
++)
{
for
(
int
j
=
W
-
1
;
j
>=
weights
[
i
];
j
--)
{
dp
[
i
][
j
]
=
Math
.
max
(
dp
[
i
-
1
][
j
],
dp
[
i
-
1
][
j
-
weights
[
i
]]
+
values
[
i
]);
}
for
(
int
j
=
weights
[
i
]
-
1
;
j
>=
0
;
j
--)
{
dp
[
i
][
j
]
=
dp
[
i
-
1
][
j
];
int
[][]
dp
=
new
int
[
N
+
1
][
W
+
1
];
for
(
int
i
=
1
;
i
<=
N
;
i
++)
{
int
w
=
weights
[
i
-
1
],
v
=
values
[
i
-
1
];
for
(
int
j
=
1
;
j
<=
W
;
j
++)
{
if
(
j
>=
w
)
{
dp
[
i
][
j
]
=
Math
.
max
(
dp
[
i
-
1
][
j
],
dp
[
i
-
1
][
j
-
w
]
+
v
);
}
else
{
dp
[
i
][
j
]
=
dp
[
i
-
1
][
j
];
}
}
}
return
dp
[
N
-
1
][
W
-
1
];
return
dp
[
N
][
W
];
}
```
...
...
@@ -2074,7 +2073,22 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
<div
align=
"center"
><img
src=
"https://latex.codecogs.com/gif.latex?dp[j]=max(dp[j],dp[j-w]+v)"
/></div>
<br>
因为 dp
[
j-w] 表示 dp[i-1
][
j-w
]
,因此不能先求 dp
[
i
][
j-w
]
防止将 dp
[
i-1
][
j-w
]
覆盖。也就是说要先计算 dp
[
i
][
j
]
再计算 dp
[
i
][
j-w
]
,在程序实现时需要按倒序来循环求解。
因为 dp
[
j-w] 表示 dp[i-1
][
j-w
]
,因此不能先求 dp
[
i
][
j-w
]
,以防止将 dp
[
i-1
][
j-w
]
覆盖。也就是说要先计算 dp
[
i
][
j
]
再计算 dp
[
i
][
j-w
]
,在程序实现时需要按倒序来循环求解。
```
java
public
int
knapsack
(
int
W
,
int
N
,
int
[]
weights
,
int
[]
values
)
{
int
[]
dp
=
new
int
[
W
+
1
];
for
(
int
i
=
1
;
i
<=
N
;
i
++)
{
int
w
=
weights
[
i
-
1
],
v
=
values
[
i
-
1
];
for
(
int
j
=
W
;
j
>=
1
;
j
--)
{
if
(
j
>=
w
)
{
dp
[
j
]
=
Math
.
max
(
dp
[
j
],
dp
[
j
-
w
]
+
v
);
}
}
}
return
dp
[
W
];
}
```
**无法使用贪心算法的解释**
...
...
@@ -2088,13 +2102,13 @@ public int knapsack(int W, int N, int[] weights, int[] values) {
**变种**
完全背包:物品可以无限个,可以转换为 0-1 背包,令每种物品的体积和价值变为 1/2/4... 倍数,把它们都当成一个新物品,然后一种物品只能添加一次。
-
完全背包:物品数量为无限个
多重背包:物品数量有限制,同样可以转换为 0-1 背包。
-
多重背包:物品数量有限制
多维费用背包:物品不仅有重量,还有体积,同时考虑这两种限制。
-
多维费用背包:物品不仅有重量,还有体积,同时考虑这两种限制
其它:物品之间相互约束或者依赖。
-
其它:物品之间相互约束或者依赖
**划分数组为和相等的两部分**
...
...
编辑
预览
Markdown
is supported
0%
请重试
或
添加新附件
.
添加附件
取消
You are about to add
0
people
to the discussion. Proceed with caution.
先完成此消息的编辑!
取消
想要评论请
注册
或
登录