C++前缀和算法的应用：2209用地毯覆盖后的最少白色砖块

本文链接：https://blog.csdn.net/he_zhidan/article/details/134053173

本文涉及的基础知识点

LeetCode2209用地毯覆盖后的最少白色砖块

给你一个下标从 0 开始的二进制字符串 floor ，它表示地板上砖块的颜色。
floor[i] = ‘0’ 表示地板上第 i 块砖块的颜色是黑色。
floor[i] = ‘1’ 表示地板上第 i 块砖块的颜色是白色。
同时给你 numCarpets 和 carpetLen 。你有 numCarpets 条黑色的地毯，每一条黑色的地毯长度都为 carpetLen 块砖块。请你使用这些地毯去覆盖砖块，使得未被覆盖的剩余白色砖块的数目最小。地毯相互之间可以覆盖。
请你返回没被覆盖的白色砖块的最少数目。
示例 1：
输入：floor = “10110101”, numCarpets = 2, carpetLen = 2
输出：2
解释：
上图展示了剩余 2 块白色砖块的方案。
没有其他方案可以使未被覆盖的白色砖块少于 2 块。
示例 2：
输入：floor = “11111”, numCarpets = 2, carpetLen = 3
输出：0
解释：
上图展示了所有白色砖块都被覆盖的一种方案。
注意，地毯相互之间可以覆盖。
参数范围:
1 <= carpetLen <= floor.length <= 1000
floor[i] 要么是 ‘0’ ，要么是 ‘1’ 。
1 <= numCarpets <= 1000

分析

原理

毛毯尽量不相互覆盖，这样可以覆盖更多的白砖。除非：毛毯放不下了。
如果能够覆盖一张毛毯，那么一定可以覆盖无限毛毯。除非 floor.length 小于carpetLen，否则一定可以覆盖。这种情况题目已经排除了。
计算最多可以盖住多少块白砖，白砖数减去盖住的白砖，就是未盖住的白砖数。
假定新毯子覆盖在[iPre,iPre + carpetLen)，那么前一张毯子不一定在[iPre-carpetLen,iPre)，可以更前。所以执行：
dp[i + 1] = max(dp[i], dp[i + 1]);
执行之前：dp[i]的含义是i的最后一张毯子的尾部，可以覆盖最多砖瓦数。
执行之后：dp[i]的含义是的最后一张毯子的尾部<=i，可以覆盖最多砖瓦数。

时间复杂度

O(n*n)。两层循环，第一层，枚举第i张毛毯。第二层循环，枚举上一次的覆盖位置。

步骤

一，计算白砖数量的前缀和。
二，两层循环。
##　变量解释


vSum	vSum[i]表示 floor[0,i)中白砖的数量，也就是前i块砖中，白砖的数量
pre	表示i块毯子，覆盖了[0,i)，能盖住的最多白砖数

代码

核心代码

class Solution {
public:
int minimumWhiteTiles(string floor, int numCarpets, int carpetLen) {
//错误想法：如果盖毯子，则毯子的末端一定盖住白砖
//计算最多可以盖住多少块白砖
vector vSum = { 0 };//vSum[i]表示 floor[0,i)中白砖的数量
for (const char& ch : floor)
{
vSum.emplace_back(vSum.back() + (‘1’ == ch));
}
m_c = floor.length();
vector pre (m_c+1,0);//表示i块毯子，覆盖了[0,i)，能盖住的最多白砖数
for (int i = 0; i < numCarpets; i++)
{
vector dp = pre;
for (int iPre = 0; iPre < pre.size(); iPre++)
{
const int iNew = min(m_c , iPre + carpetLen);
dp[iNew] = max(dp[iNew], pre[iPre] + (vSum[iNew]-vSum[iPre]));
}
for (int i = 0; i < m_c; i++)
{
dp[i + 1] = max(dp[i], dp[i + 1]);
}
pre.swap(dp);
}
return vSum.back() - *std::max_element(pre.begin(),pre.end());
}
int m_c;
};

测试用例

template
void Assert(const vector& v1, const vector& v2)
{
if (v1.size() != v2.size())
{
assert(false);
return;
}
for (int i = 0; i < v1.size(); i++)
{
assert(v1[i] == v2[i]);
}
}

template
void Assert(const T& t1, const T& t2)
{
assert(t1 == t2);
}

int main()
{
Solution slu;
string floor = “10110101”;
int numCarpets = 2, carpetLen = 2;
int res;

floor = "1110111";
numCarpets = 2, carpetLen = 3;
res = slu.minimumWhiteTiles(floor, numCarpets, carpetLen);
Assert(0, res);

floor = "10110101";
numCarpets = 2, carpetLen = 2;
res = slu.minimumWhiteTiles(floor, numCarpets, carpetLen);
Assert(2, res);

floor = "11111";
numCarpets = 2, carpetLen = 3;
res = slu.minimumWhiteTiles(floor, numCarpets, carpetLen);
Assert(0, res);	


//CConsole::Out(res);

}

2023年2月旧代码

class Solution {
public:
int minimumWhiteTiles(const string floor, const int numCarpets, const int carpetLen) {
m_c = floor.length();
//dp[i][j] 已经处理了i块砖，用了j块地毯，最少为覆盖的砖数
vector<vector> dp(m_c+1, vector(numCarpets+1,INT_MAX));
dp[0][0] = 0;
for (int brick = 0; brick < m_c; brick++)
{
for (int iUseCarpets = 0; iUseCarpets <= numCarpets; iUseCarpets++)
{
const int& iValue = dp[brick][iUseCarpets];
if (INT_MAX == iValue)
{
continue;
}
//空一格
dp[brick + 1][iUseCarpets] = min(dp[brick + 1][iUseCarpets], iValue + (‘1’ == floor[brick]));
//假定不重叠，如果重叠右移到不重叠，不影响结果
if (numCarpets == iUseCarpets)
{
continue;
}
const int iNewBrick = min(brick + carpetLen, m_c);
dp[iNewBrick][iUseCarpets + 1] = min(dp[iNewBrick][iUseCarpets + 1], iValue);
}
}
return *std::min_element(dp[m_c].begin(), dp[m_c].end());
}
int m_c;
};