【状态机动态规划】3129 3130 找出所有稳定的二进制数组 I

最新推荐文章于 2024-08-17 08:45:02 发布
最新推荐文章于 2024-08-17 08:45:02 发布
阅读量962 收藏 32
点赞数 12
文章标签： 动态规划 算法 矩阵 c++ 状态机dp 稳定 二进制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/139810890
版权

本文涉及知识点

动态规划汇总 状态机动态规划

LeetCode3130. 找出所有稳定的二进制数组 II

给你 3 个正整数 zero ，one 和 limit 。
一个 二进制数组 arr 如果满足以下条件，那么我们称它是 稳定的 ：
0 在 arr 中出现次数 恰好 为 zero 。
1 在 arr 中出现次数 恰好 为 one 。
arr 中每个长度超过 limit 的 子数组 都 同时 包含 0 和 1 。
请你返回 稳定 二进制数组的 总 数目。
由于答案可能很大，将它对 109 + 7 取余 后返回。
示例 1：
输入：zero = 1, one = 1, limit = 2
输出：2
解释：
两个稳定的二进制数组为 [1,0] 和 [0,1] ，两个数组都有一个 0 和一个 1 ，且没有子数组长度大于 2 。
示例 2：
输入：zero = 1, one = 2, limit = 1
输出：1
解释：
唯一稳定的二进制数组是 [1,0,1] 。
二进制数组 [1,1,0] 和 [0,1,1] 都有长度为 2 且元素全都相同的子数组，所以它们不稳定。
示例 3：
输入：zero = 3, one = 3, limit = 2
输出：14
解释：
所有稳定的二进制数组包括 [0,0,1,0,1,1] ，[0,0,1,1,0,1] ，[0,1,0,0,1,1] ，[0,1,0,1,0,1] ，[0,1,0,1,1,0] ，[0,1,1,0,0,1] ，[0,1,1,0,1,0] ，[1,0,0,1,0,1] ，[1,0,0,1,1,0] ，[1,0,1,0,0,1] ，[1,0,1,0,1,0] ，[1,0,1,1,0,0] ，[1,1,0,0,1,0] 和 [1,1,0,1,0,0] 。

3129要求：

1 <= zero, one, limit <= 200

3130要求：

1 <= zero, one, limit <= 1000

动态规划

动态规划的状态表示

dp0[i][j][k] 记录长度为i+1的arr，以j个0结尾，且0的总数量为k的方案数。
dp1[i][j][k] 记录长度为i+1的arr，以j个1结尾，且0的总数量为k的方案数。
利用滚动向量，空间复杂度:O(limit × \times × zero)

动态规划的转移方程

枚举每种前置状态，枚举当前元素为1或0。
时间复杂度：O(limit × \times × zero × \times × (zero+one))

动态规划的初始值

pre0[0][0] =1 其它pre0为0
pre1为0。

动态规划的填表顺序

for i = 0 To zero+one-1

动态规格的返回值

sum(pre0) + sum(pre1)

代码

此方法 在超时和超内存的边缘，需要优化代码。

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator/(const C1097Int& o)const
	{
		return *this * o.PowNegative1();
	}
	C1097Int& operator/=(const C1097Int& o)
	{
		*this /= o.PowNegative1();
		return *this;
	}
	bool operator==(const C1097Int& o)const
	{
		return m_iData == o.m_iData;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

class Solution {
public:
	int numberOfStableArrays(int zero, int one, int limit) {
		vector<vector<C1097Int<>>> pre0(limit+1,vector<C1097Int<>>(zero +1));
		auto pre1 = pre0, dp0 = pre0, dp1 = pre0;
		pre0[0][0] = 1;
		for (int i = 0; i  < zero + one; i++) {
			dp0.assign(limit + 1, vector<C1097Int<>>(zero + 1));
			dp1.assign(limit + 1, vector<C1097Int<>>(zero + 1));
			C1097Int<> biSum;
			for (int k = 0; k < zero; k++) {
				for (int j = 0; j < limit; j++) {//00
					dp0[j + 1][k + 1] += pre0[j][k];
				}				
			}
			for (int k = max(0,i-one); k < zero; k++) {
				for (int j = 0; j <= limit; j++) {//10
					dp0[1][k + 1] += pre1[j][k];
				}
			}
			for (int k = max(0, i + 1- one); k <= zero; k++) {
				for (int j = 0; j < limit; j++) {//...11
					dp1[j + 1][k] += pre1[j][k];
				}
				for (int j = 0; j <= limit; j++) {//...01
					dp1[1][k] += pre0[j][k];
				}
			}
			pre0.swap(dp0);
			pre1.swap(dp1);
		}
		C1097Int<> biRet;
		for (int j = 0; j <= limit; j++) {
			for (int k = 0; k <= zero; k++) {
				biRet += pre0[j][k] + pre1[j][k];
			}
		}
		return biRet.ToInt();
	}
};

单元测试

template<class T1, class T2>
void AssertEx(const T1& t1, const T2& t2)
{
	Assert::AreEqual(t1, t2);
}

template<class T>
void AssertEx(const vector<T>& v1, const vector<T>& v2)
{
	Assert::AreEqual(v1.size(), v2.size());
	for (int i = 0; i < v1.size(); i++)
	{
		Assert::AreEqual(v1[i], v2[i]);
	}
}

template<class T>
void AssertV2(vector<vector<T>> vv1, vector<vector<T>> vv2)
{
	sort(vv1.begin(), vv1.end());
	sort(vv2.begin(), vv2.end());
	Assert::AreEqual(vv1.size(), vv2.size());
	for (int i = 0; i < vv1.size(); i++)
	{
		AssertEx(vv1[i], vv2[i]);
	}
}

namespace UnitTest
{
	int zero,  one,  limit;
	TEST_CLASS(UnitTest)
	{
	public:
		TEST_METHOD(TestMethod0)
		{
			zero = 1, one = 1, limit = 2;
			auto res = Solution().numberOfStableArrays(zero, one, limit);
			AssertEx(2, res);
		}
		TEST_METHOD(TestMethod2)
		{
			zero = 1, one = 2, limit = 1;
			auto res = Solution().numberOfStableArrays(zero, one, limit);
			AssertEx(1, res);
		}
		TEST_METHOD(TestMethod3)
		{
			zero = 3, one = 3, limit = 2;
			auto res = Solution().numberOfStableArrays(zero, one, limit);
			AssertEx(14, res);
		}
		TEST_METHOD(TestMethod4)
		{
			zero = 200, one = 200, limit = 200;
			auto res = Solution().numberOfStableArrays(zero, one, limit);
			AssertEx(587893473, res);
		}
	};
}

优化后的状态机动态规划

动态规格的状态

dp0[i][j] 表示以0结尾，长度为i，0的数量为j 的方案数(连续0或1不超过limit个）。
dp1 表示以1结尾的合法方案数。
空间复杂度：O((zero+one)zeor)

动态规划的转移方程

枚举每种状态，看能否追加0或1。转移方程的时间复杂度：O(1)，故时间复杂度等于空间复杂度。
如何扣除 dp1[i+1][j] 新增加的超过limit限制?
arr[0…i-1]没超限， arr[0…i]超限，说明：arr最后limit+1 全部是1，且前面的字符不是1，是0。即扣掉：
dp0[i - limit ][j];
limit+1个零类似。

动态规程的初始状态

	dp0[0][0] = dp1[0][0]= 1;
		dp0[1][1] = dp1[1][0] = 1;

动态规划的填表顺序

for (int i = 1; i < zero + one; i++)

动态规划的返回值

sum(dp0.back()) + sum(dp1.back())

代码

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator/(const C1097Int& o)const
	{
		return *this * o.PowNegative1();
	}
	C1097Int& operator/=(const C1097Int& o)
	{
		*this /= o.PowNegative1();
		return *this;
	}
	bool operator==(const C1097Int& o)const
	{
		return m_iData == o.m_iData;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

class Solution {
public:
	int numberOfStableArrays(int zero, int one, int limit) {
		vector<vector<C1097Int<>>> dp0(zero+one +1,vector<C1097Int<>>(zero +1));
		auto dp1 = dp0;
		dp0[0][0] = dp1[0][0]= 1;
		dp0[1][1] = dp1[1][0] = 1;
		for (int i = 1; i  < zero + one; i++) {
			for (int j = 0; j < zero; j++) {//追加0
				dp0[i + 1][j + 1] += dp0[i][j];//...00
				if ((i - limit >= 0)&&(j - limit>=0)){//扣掉末尾limit+1个0
					dp0[i + 1][j + 1] -= dp1[i - limit ][j-limit];
				}
				dp0[i + 1][j + 1] += dp1[i][j];//...10
			}
			for (int j = max(0,i+1-one); j <= zero; j++) {//追加1
				dp1[i + 1][j ] += dp1[i][j];//...11
				if (i - limit  >= 0) {//扣掉末尾limit+1个1
					dp1[i + 1][j] -= dp0[i - limit ][j];
				}
				dp1[i + 1][j ] += dp0[i][j];//...01				
			}
		}
		C1097Int<> biRet;
		for (int k = 0; k <= zero; k++) {
			biRet += dp0.back()[k] + dp1.back()[k];
		}
		return biRet.ToInt();
	}
};

扩展阅读

视频课程

先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

相关推荐

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
按类别查阅鄙人的算法文章，请点击《算法与数据汇总》。
有效学习：明确的目标 及时的反馈 拉伸区（难度合适） 专注
闻缺陷则喜(喜缺)是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

操作系统：win7 开发环境： VS2019 C++17
或者 操作系统：win10 开发环境： VS2022 C++17
如无特殊说明，本算法用**C++**实现。

闻缺陷则喜何志丹
关注
  • 12
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
【状态机动态规划】3129. 找出所有稳定的二进制数组 I
闻缺陷则喜何志丹
05-28 867
给你 3 个正整数 zero ，one 和 limit 。 一个 二进制数组 arr 如果满足以下条件，那么我们称它是 稳定的 ： 0 在 arr 中出现次数 恰好 为 zero 。 1 在 arr 中出现次数 恰好 为 one 。 arr 中每个长度超过 limit 的 子数组 都 同时 包含 0 和 1 。 请你返回 稳定 二进制数组的 总 数目。 由于答案可能很大，将它对 109 + 7 取余 后返回。
最全动态规划题型详解
阿华的保温杯的博客
11-17 5983
通俗的讲动态规划（dp）的核心就是记住已经解决过子问题的解，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。dp常常适用于有重叠子问题和最优子结构性质的问题,动态规划方法所消耗的时间往往远小于朴素解法。
Java之有限状态机
qq_43164662的博客
11-02 2585
HashMap、位运算、有限状态机，顾名思义有限个状态在事件的触发下做出相应状态的转换。
易语言数组比较模块
08-16
在数组处理中，这种比较通常用于验证数据的正确性或找出数据差异。例如，在数据同步或数据校验的场景中，可以利用这个函数来确保两个系统中的整数数据一致。 2. **比较数组不同_文本**：文本数组的比较则涉及到字符...
2021-2022计算机二级等级考试试题及答案No.11762.docx
10-26
- **生成表查询**: 将成绩在90分以上的记录找出后放入一个新的表中，这通常通过**生成表查询**来完成。生成表查询是从一个或多个表中选择满足条件的记录，并将这些记录插入到新的表中。 ### 2. 计算机网络 - **电子...
2021-2022计算机二级等级考试试题及答案No.11003.docx
10-25
3. 软件调试的主要目的是找出并改正程序中的错误，确保软件能够正常、无误地运行。这是软件开发过程中的重要环节。 4. HTML中的`<title>`标签用于定义网页的标题，显示在浏览器的标题栏或标签页上，同时也是搜索...
2021-2022计算机二级等级考试试题及答案No.9554.docx
11-04
尽管软件测试可以帮助评估软件的可靠性，但其核心目标是找出潜在的问题，以便开发人员能够修复它们。 ### 15. 关系数据库设计阶段 - **知识点概述**：关系数据库设计的不同阶段。 - **详细解释**：关系数据库设计...
2021-2022计算机二级等级考试试题及答案No.10673.docx
10-25
该算法遍历数组，对于每个元素，找出在其后面元素中的最小值，并与当前元素交换位置。最终效果是将数组的部分元素从小到大排序。在这个例子中，数组的中间部分 `{3, 4, 5, 6, 7}` 被排序为 `{3, 4, 5, 6, 7}`，因此...
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 381
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1169
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 723
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
Day 2:3107 使数组中位数等于k的最少操作数
qewa132的博客
08-13 486
数组从小到大排序，注意到。位置处的值为中位数；
算法之递归和迭代
qq_28576837的博客
08-16 266
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 259
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
【算法模板】计算几何：点类与线类
2303_80346267的博客
08-13 347
计算几何（Computational Geometry）是计算机科学中的一个分支，专注于研究几何问题的算法和数据结构。它主要涉及几何对象（如点、线段、多边形等）的表示、操作和分析，旨在高效地解决几何问题。
算法笔记：空间填充曲线
最新发布
qq_40206371的博客
08-17 113
六次迭代的希尔伯特曲线：
算法刷题day35|动态规划：121. 买卖股票的最佳时机、122. 买卖股票的最佳时机 II、123. 买卖股票的最佳时机 III
qq_61936886的博客
08-15 469
同样dp[i][1]取最大的，dp[i][1] = max(dp[i - 1][1], prices[i] + dp[i - 1][0]);那么dp[i][0]应该选所得现金最大的，所以dp[i][0] = max(dp[i - 1][0], -prices[i]);一定是选最大的，所以 dp[i][1] = max(dp[i-1][0] - prices[i], dp[i - 1][1]);那么dp[i][1]究竟选 dp[i-1][0] - prices[i]，还是dp[i - 1][1]呢？
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

闻缺陷则喜何志丹

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值