20210606 每日一题 一和零

题目

题目链接

代码

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {

    }
};

方法一：三维动态规划

分析

题目是一个多维背包问题，把总共的 $0$ 和 $1$ 的个数视为背包的容量，每一个字符串视为装进背包的物品，因此需要使用三维动态规划求解，三个维度分别是字符串数量 $i$、$0$ 的容量 $j$ 和 $1$ 的容量 $k$。因此，设定三维数组 $dp[i][j][k]$ 表示在前 $i$ 个字符串中，使用最多不超过 $j$ 个 $0$ 和 $k$ 个 $1$ 的情况下可以得到的字符串的最大数量，三维数组 $dp[i][j][k]$ 起始值 $0$。假设第 $i$ 个字符串包含有 $x$ 个 $0$， $y$ 个 $1$，对第 $i$ 个字符串有选和不选两种情况：

• 如果 $j\ge x\&k\ge y$ 时，假设第 $i$ 个字符串不在最大子集中时，则有 $dp[i][j][k]=dp[i-1][j][k]$；假设第 $i$ 个字符串在最大子集中时，则有 $dp[i][j][k]=dp[i-1][j-x][k-y]$。$dp[i][j][k]$ 应取两者中较大的一个。
• 如果 $j<x|k<y$ 时，则不能选第 $i$ 个字符串，所包含的 $0$ 和 $1$ 数量已经超过限定值，第 $i$ 个字符串不在最大子集中，因此 $dp[i][j][k]=dp[i-1][j][k]$。

综上所述 $dp[i][j][k]$ 的状态转移方程可表示为：
$$dp[i][j][k]=\{\begin{array}{ll}max(dp[i-1][j][k],dp[i-1][j-x][k-y]+1)& ifj\ge x\&k\ge y\\ dp[i-1][j][k]& ifj<x|k<y\end{array}$$ $dp[l][m][n]$ 即为问题答案。
为使程序简洁，我们将对字符串中 $0$ 和 $1$ 数量计数部分单独提出作为函数 $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(lmn+L)$，其中 $l$ 是字符串数量，$m$ 和 $n$ 分别是 $0$ 和 $1$ 的最大容量，$L$ 是所有字符串的长度之和。
• 空间复杂度：$O(lmn)$，其中 $l$ 是字符串数量，$m$ 和 $n$ 分别是 $0$ 和 $1$ 的最大容量，实现动态规划需要创建 $(l+1)\times (m+1)\times (n+1)$ 的三维数组 $dp$。

方法二：二维动态规划

分析

根据方法一的状态转移方程可知，更新 $dp[i][][]$ 的每个元素值时，只依赖于 $dp[i-1][][]$ 的元素值。因此，可以使用一维滚动数组 $dp[j][k]$ 来替代三维数组 $dp[i][j][k]$ 对方法一进行空间上的优化。$dp[j][k]$ 的状态转移方程可表示为：
$$dp[j][k]=max(dp[j][k],dp[j-x][k-y]+1)$$ $dp[m][n]$ 即为问题答案。

要点

根据方法一的状态转移方程，对于 $dp[i][j][k]$ 元素值的更新，只与 $dp[i-1][a][b](a\le j,b\le k)$相关，实现时，$j$, $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(lmn+L)$，其中 $l$ 是字符串数量，$m$ 和 $n$ 分别是 $0$ 和 $1$ 的最大容量，$L$ 是所有字符串的长度之和。
• 空间复杂度：$O(mn)$，其中 $m$ 和 $n$ 分别是 $0$ 和 $1$ 的最大容量，实现动态规划需要创建 $(m+1)\times (n+1)$ 的二位滚动数组 $dp$。

优化

• 可以将内部两层循环语句 $for$ 和判定语句 $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);
	}
}

• 可以使用两个 $int$ 值分别存储当前字符串 $strs[i]$ 中 $0$ 和 $1$ 的数量，以减少对 $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];
    }
};

拓展