题目
代码
class Solution {
public:
int findMaxForm(vector<string>& strs, int m, int n) {
}
};
方法一:三维动态规划
分析
题目是一个多维背包问题,把总共的 0 0 0 和 1 1 1 的个数视为背包的容量,每一个字符串视为装进背包的物品,因此需要使用三维动态规划求解,三个维度分别是字符串数量 i i i、 0 0 0 的容量 j j j 和 1 1 1 的容量 k k k。因此,设定三维数组 d p [ i ] [ j ] [ k ] dp[i][j][k] dp[i][j][k] 表示在前 i i i 个字符串中,使用最多不超过 j j j 个 0 0 0 和 k k k 个 1 1 1 的情况下可以得到的字符串的最大数量,三维数组 d p [ i ] [ j ] [ k ] dp[i][j][k] dp[i][j][k] 起始值 0 0 0。假设第 i i i 个字符串包含有 x x x 个 0 0 0, y y y 个 1 1 1,对第 i i i 个字符串有选和不选两种情况:
- 如果 j ≥ x & k ≥ y j \geq x\ \&\ k \geq y j≥x & k≥y 时,假设第 i i i 个字符串不在最大子集中时,则有 d p [ i ] [ j ] [ k ] = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]=dp[i-1][j][k] dp[i][j][k]=dp[i−1][j][k];假设第 i i i 个字符串在最大子集中时,则有 d p [ i ] [ j ] [ k ] = d p [ i − 1 ] [ j − x ] [ k − y ] dp[i][j][k]=dp[i-1][j-x][k-y] dp[i][j][k]=dp[i−1][j−x][k−y]。 d p [ i ] [ j ] [ k ] dp[i][j][k] dp[i][j][k] 应取两者中较大的一个。
- 如果 j < x ∣ k < y j < x\ | \ k < y j<x ∣ k<y 时,则不能选第 i i i 个字符串,所包含的 0 0 0 和 1 1 1 数量已经超过限定值,第 i i i 个字符串不在最大子集中,因此 d p [ i ] [ j ] [ k ] = d p [ i − 1 ] [ j ] [ k ] dp[i][j][k]=dp[i-1][j][k] dp[i][j][k]=dp[i−1][j][k]。
综上所述
d
p
[
i
]
[
j
]
[
k
]
dp[i][j][k]
dp[i][j][k] 的状态转移方程可表示为:
d
p
[
i
]
[
j
]
[
k
]
=
{
m
a
x
(
d
p
[
i
−
1
]
[
j
]
[
k
]
,
d
p
[
i
−
1
]
[
j
−
x
]
[
k
−
y
]
+
1
)
i
f
j
≥
x
&
k
≥
y
d
p
[
i
−
1
]
[
j
]
[
k
]
i
f
j
<
x
∣
k
<
y
dp[i][j][k] = \begin{cases} max(dp[i-1][j][k], dp[i-1][j-x][k-y]+1) &if\ j \geq x\ \&\ k \geq y\\ dp[i-1][j][k] &if\ j < x\ | \ k < y \end{cases}
dp[i][j][k]={max(dp[i−1][j][k],dp[i−1][j−x][k−y]+1)dp[i−1][j][k]if j≥x & k≥yif j<x ∣ k<y
d
p
[
l
]
[
m
]
[
n
]
dp[l][m][n]
dp[l][m][n] 即为问题答案。
为使程序简洁,我们将对字符串中
0
0
0 和
1
1
1 数量计数部分单独提出作为函数
c
o
u
n
t
N
u
m
b
e
r
countNumber
countNumber。
代码
class Solution {
private:
vector<int> countNumber(string& str) {
vector<int> temp (2, 0);
for(auto s : str) {
temp[s - '0']++;
}
return temp;
}
public:
int findMaxForm(vector<string>& strs, int m, int n) {
int len = strs.size();
vector<vector<vector<int>>> dp (len + 1, vector<vector<int>> (m + 1, vector<int>(n + 1, 0)));
for(int i = 1; i <= len; ++i) {
vector<int> number = countNumber(strs[i - 1]);
for(int j = 0; j <= m; ++j) {
for(int k = 0; k <= n; ++k) {
if (j >= number[0] && k >= number[1]) {
dp[i][j][k] = max(dp[i - 1][j][k], dp[i - 1][j - number[0]][k - number[1]] + 1);
} else {
dp[i][j][k] = dp[i - 1][j][k];
}
}
}
}
return dp[len][m][n];
}
};
复杂度分析
- 时间复杂度: O ( l m n + L ) O(lmn + L) O(lmn+L),其中 l l l 是字符串数量, m m m 和 n n n 分别是 0 0 0 和 1 1 1 的最大容量, L L L 是所有字符串的长度之和。
- 空间复杂度: O ( l m n ) O(lmn) O(lmn),其中 l l l 是字符串数量, m m m 和 n n n 分别是 0 0 0 和 1 1 1 的最大容量,实现动态规划需要创建 ( l + 1 ) × ( m + 1 ) × ( n + 1 ) (l+1)\times(m+1)\times(n+1) (l+1)×(m+1)×(n+1) 的三维数组 d p dp dp。
方法二:二维动态规划
分析
根据方法一的状态转移方程可知,更新
d
p
[
i
]
[
]
[
]
dp[i][][]
dp[i][][] 的每个元素值时,只依赖于
d
p
[
i
−
1
]
[
]
[
]
dp[i-1][][]
dp[i−1][][] 的元素值。因此,可以使用一维滚动数组
d
p
[
j
]
[
k
]
dp[j][k]
dp[j][k] 来替代三维数组
d
p
[
i
]
[
j
]
[
k
]
dp[i][j][k]
dp[i][j][k] 对方法一进行空间上的优化。
d
p
[
j
]
[
k
]
dp[j][k]
dp[j][k] 的状态转移方程可表示为:
d
p
[
j
]
[
k
]
=
m
a
x
(
d
p
[
j
]
[
k
]
,
d
p
[
j
−
x
]
[
k
−
y
]
+
1
)
dp[j][k] = max(dp[j][k], dp[j-x][k-y]+1)
dp[j][k]=max(dp[j][k],dp[j−x][k−y]+1)
d
p
[
m
]
[
n
]
dp[m][n]
dp[m][n] 即为问题答案。
要点
根据方法一的状态转移方程,对于 d p [ i ] [ j ] [ k ] dp[i][j][k] dp[i][j][k] 元素值的更新,只与 d p [ i − 1 ] [ a ] [ b ] ( a ≤ j , b ≤ k ) dp[i-1][a][b] \ (a \leq j,\ b \leq k) dp[i−1][a][b] (a≤j, b≤k)相关,实现时, j j j, k k k 所在的内层循环需采用倒序遍历的方式更新元素值。
代码
class Solution {
private:
vector<int> countNumber(string& str) {
vector<int> temp (2, 0);
for(auto s : str) {
temp[s - '0']++;
}
return temp;
}
public:
int findMaxForm(vector<string>& strs, int m, int n) {
int len = strs.size();
vector<vector<int>> dp (m + 1, vector<int>(n + 1, 0));
for(int i = 0; i < len; ++i) {
vector<int> number = countNumber(strs[i]);
for(int j = m; j >= 0; --j) {
for(int k = n; k >= 0; --k) {
if (j >= number[0] && k >= number[1]) {
dp[j][k] = max(dp[j][k], dp[j - number[0]][k - number[1]] + 1);
}
}
}
}
return dp[m][n];
}
};
复杂度分析
- 时间复杂度: O ( l m n + L ) O(lmn + L) O(lmn+L),其中 l l l 是字符串数量, m m m 和 n n n 分别是 0 0 0 和 1 1 1 的最大容量, L L L 是所有字符串的长度之和。
- 空间复杂度: O ( m n ) O(mn) O(mn),其中 m m m 和 n n n 分别是 0 0 0 和 1 1 1 的最大容量,实现动态规划需要创建 ( m + 1 ) × ( n + 1 ) (m+1)\times(n+1) (m+1)×(n+1) 的二位滚动数组 d p dp dp。
优化
- 可以将内部两层循环语句 f o r for for 和判定语句 i f if if 进行合并,以减少无用计算量。
for(int j = m; j >= zeros; --j) {
for(int k = n; k >= ones; --k) {
dp[j][k] = max(dp[j][k], dp[j - zeros][k - ones] + 1);
}
}
- 可以使用两个 i n t int int 值分别存储当前字符串 s t r s [ i ] strs[i] strs[i] 中 0 0 0 和 1 1 1 的数量,以减少对 v e c t o r vector vector 的查找。
vector<int> number = countNumber(strs[i]);
int zeros = number[0], ones = number[1];
代码
class Solution {
private:
vector<int> countNumber(string& str) {
vector<int> temp (2, 0);
for(auto s : str) {
temp[s - '0']++;
}
return temp;
}
public:
int findMaxForm(vector<string>& strs, int m, int n) {
int len = strs.size();
vector<vector<int>> dp (m + 1, vector<int>(n + 1, 0));
for(int i = 0; i < len; ++i) {
vector<int> number = countNumber(strs[i]);
int zeros = number[0], ones = number[1];
for(int j = m; j >= zeros; --j) {
for(int k = n; k >= ones; --k) {
dp[j][k] = max(dp[j][k], dp[j - zeros][k - ones] + 1);
}
}
}
return dp[m][n];
}
};