动态规划-leetcode474一和零问题

问题描述

在计算机界中，我们总是追求用有限的资源获取最大的收益。

现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。

你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于数组中的字符串的最大数量。每个 0 和 1 至多被使用一次。

注意:

1. 给定 0 和 1 的数量都不会超过 100。
2. 给定字符串数组的长度不会超过 600。

示例 1:

输入: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
输出: 4

解释: 总共 4 个字符串可以通过 5 个 0 和 3 个 1 拼出，即 "10","0001","1","0" 。

示例 2:

输入: Array = {"10", "0", "1"}, m = 1, n = 1
输出: 2

解释: 你可以拼出 "10"，但之后就没有剩余数字了。更好的选择是拼出 "0" 和 "1" 。

解题思路

由于博主对于动态并不是很擅长，所以我一开始可以想到的解法就是时间复杂度比较高的O(2^n)递归解法，因为递归可能比较好理解一点的缘故吧，但是，进步总是要有过程的，所以我这里先提供简单的递归解法的步骤。

我这里先简单分析题意，其实，题意也是比较简单的题的类型。简答来说就是给你一个字符串(string)数组，这些string的字符串中只包含了有由"0"和"1"组成的字符串。然后再给你一个M(代表给你0的个数)N(代表给你1的个数)。

然后让你找出可以匹配0和1的最大string的个数。

这种题目一看就是要用动态规划去解决的。

笨办法---递归

首先分析题意写出状态转移方程

我们假设F(L,M,N)=>代表的意思是为剩下的L个字符串中，用M个0和N个1所能构成的最优解(就是可以组成剩下字符串的最大的个数)

那么我们不难看出示例一中的最优解为(常规式)

//我们从后往前对每个字符串都有俩种情况就是(选择和不选择)

F(5,5,3)=max(F(4,4,3)+1,F(4,5,3));

我们考虑这个递归什么情况下退出循环呢？

当我们的m==0&&n==0（就是说我们的所有给定的资源用完）

还有我们的字符串遍历结束(i==-1)情况下都为递归的终止条件

 

当然我们也不能忘记特殊条件(当前给定的资源(0和1的个数不足以匹配当前的字符串))

F(L,M,N)=F(L-1,M,N);

 

于是我们不难写出代码:

class Solution {
public:
	int getM(string &strs)
	{
		int total = 0;
		auto it = strs.begin();
		for (; it != strs.end(); ++it)
		{
			if (*it == '0')
				total++;
		}
		return total;
	}
	int getN(string &strs)
	{
		int total = 0;
		auto it = strs.begin();
		for (; it != strs.end(); ++it)
		{
			if (*it == '1')
				total++;
		}
		return total;
	}
	int Opt(vector<string>& strs, int i, int m, int n)
	{
		if ((m == 0 && n == 0) || i == -1)
			return 0;
		if (getM(strs[i]) > m || getN(strs[i]) > n)
			return Opt(strs, i - 1, m, n);
		return max(1 + Opt(strs, i - 1, m - getM(strs[i]), n - getN(strs[i])), Opt(strs, i - 1, m, n));
	}
	int findMaxForm(vector<string>& strs, int m, int n) {
		return Opt(strs, strs.size() - 1, m, n);
	}
};

遗憾的是这种算法的时间复杂度太高O(n^2),我们的代码无法通过leetcode。

所以我们便不得已找到更好的解法，也就是使用二维数组存放结果。返回最终的dp二维数组的最后一个元素的值的方法。

 

自底向上的解法

构建二维数组法求解问题，我们这里构建的相当于是以0的个数+1(M+1)作为行数，1的个数＋1(N+1)作为列数，然后，遍历每个字符更新相关的位置的值此时的时间复杂度可以达到O(n*m*count);

class Solution {
public:
    int getM(string &strs)
    {
        int total = 0;
        auto it = strs.begin();
        for(;it != strs.end();++it)
        {
            if(*it == '0')
                total++;
        }
        return total;
    }
    int getN(string &strs)
    {
        int total = 0;
        auto it = strs.begin();
        for(;it != strs.end();++it)
        {
            if(*it == '1')
                total++;
        }
        return total;
    }
    int Opt(vector<string>& strs,int i,int m,int n)
    {
        vector<vector<int>> dp(m + 1, vector<int>(n+1));
		for (int i = 0; i < strs.size(); i++)
		{
			int zero = getM(strs[i]);
			int one = getN(strs[i]);
			
			for (int j = m; j >= zero; j--)
			{
				for (int k = n; k >= one; k--)
				{
					dp[j][k] = max(dp[j][k], dp[j - zero][k - one] + 1);
				}
			}
		}
		return dp[m][n];
    }
    int findMaxForm(vector<string>& strs, int m, int n) {
        return Opt(strs,strs.size()-1,m,n);
    }
};