【前缀和 记忆化搜索】LeetCode1444. 切披萨的方案数

最新推荐文章于 2024-07-25 11:27:31 发布
最新推荐文章于 2024-07-25 11:27:31 发布
阅读量1.6k 收藏 48
点赞数 36
文章标签： C++ 算法 力扣 前缀和 动态规划 记忆化搜索 方案数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/he_zhidan/article/details/139134886
版权

本文涉及的基础知识点

C++算法：前缀和、前缀乘积、前缀异或的原理、源码及测试用例 包括课程视频
动态规划 记忆化搜索

LeetCode1444. 切披萨的方案数

给你一个 rows x cols 大小的矩形披萨和一个整数 k ，矩形包含两种字符： ‘A’ （表示苹果）和 ‘.’ （表示空白格子）。你需要切披萨 k-1 次，得到 k 块披萨并送给别人。
切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置，将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人，如果水平地切，那么需要把上面的部分送给一个人。在切完最后一刀后，需要把剩下来的一块送给最后一个人。
请你返回确保每一块披萨包含 至少 一个苹果的切披萨方案数。由于答案可能是个很大的数字，请你返回它对 10^9 + 7 取余的结果。
示例 1：
在这里插入图片描述

输入：pizza = [“A…”,“AAA”,“…”], k = 3
输出：3
解释：上图展示了三种切披萨的方案。注意每一块披萨都至少包含一个苹果。
示例 2：

输入：pizza = [“A…”,“AA.”,“…”], k = 3
输出：1
示例 3：

输入：pizza = [“A…”,“A…”,“…”], k = 1
输出：1

提示：
1 <= rows, cols <= 50
rows == pizza.length
cols == pizza[i].length
1 <= k <= 10
pizza 只包含字符 ‘A’ 和 ‘.’ 。

预处理

本题解点的坐标用(x,y)表示，而不是行列。
任何时间，待切的蛋糕一定保留原始蛋糕的右下角（cols-1,rows-1)。所以只需要枚举(left,top)。
垂直切：左边的部分，bottom一定和原始蛋糕bottom，相同。只需要枚举left,top,right。
水平且：上边的部分，right一定和原始蛋糕同。只需要枚举left,top,bottom。
vLeft[left][t][r] 记录(left,t,r,rows-1) 是否包括苹果。
vTop[left][[t][b] 记录(left,t,cols-1,b) 是否包括苹果。
计算vLeft的过程如下：
符合以下条件之一vLeft[left][t][r] 就有苹果：
一，(left,t)有苹果。
二，vLeft(left+1,t,r)有苹果。
三，vLeft(left,t+1,r)有苹果。
vTop类似。
m =max(rows,cols)。 空间复杂度O(mmm)，时间复杂也是O(mmm)。

** 可以用二维前缀和计算左边（上边)的苹果数**。

动态规划

动态的状态表示

dp[k][left][top] 表示将蛋糕(left,top,cols-1,rows-1)切k次的方案数。
空间复杂度：O(k × \times × rows × \times × cols)

动态规划的转移方程

垂直切
dp[k][left][top] += F o r x : l e f t + 1 : c o l s − 1 v L e f t [ l e f t ] [ t o p ] [ x − 1 ] 有苹果 D p ( k − 1 , x , t o p ) \large For_{x:left+1:cols-1}^{vLeft[left][top][x-1]有苹果}Dp(k-1,x,top) Forx:left+1:cols−1vLeft[left][top][x−1]有苹果​Dp(k−1,x,top)
记忆化搜索： Dp是函数，如果dp有对应值，则返回dp的值。否则更新dp的值，并返回。避免重复计算。
水平切：
dp[k][left][top] += F o r x : t o p + 1 : r o w s − 1 v T o p [ l e f t ] [ t o p ] [ x − 1 ] 有苹果 D p ( k − 1 , l e f t , x ) \large For_{x:top+1:rows-1}^{vTop[left][top][x-1]有苹果}Dp(k-1,left,x) Forx:top+1:rows−1vTop[left][top][x−1]有苹果​Dp(k−1,left,x)
注意：送出的部分必须有一个苹果，包括的部分必须有k个苹果。

时间复杂度：O(k × \times × rows × \times × cols × \times × (rows+cols))

动态规划的初始值

dp[0][left][top] = (left,top,m_iC-1,m_iR-1)是否有苹果。 如果是记忆化搜索，还需要vHasDo 记录各状态是否处理。

动态规划的填表顺序

直接Do(k-1,0,0) 是记忆化搜索。从1到k 计算所有状态的值，是动态规划。记忆化搜索可以避免计算一些不需要计算的值。

动态规划的返回值

dp[k][0][0]

代码

核心代码

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;;
};

template<class T = int>
class CPreSum2 {
public:
	template<class _Pr>
	CPreSum2(int rowCnt, int colCount, _Pr pr):m_iRowCnt(rowCnt),m_iColCnt(colCount){
		m_vSum.assign(rowCnt + 1, vector<int>(colCount + 1));
		for (int r = 0; r < rowCnt; r++) {
			for (int c = 0; c < colCount; c++) {
				m_vSum[r + 1][c + 1] = m_vSum[r][c + 1] + m_vSum[r + 1][c] - m_vSum[r][c] + pr(r, c);
			}
		}
	}
	T Get(int left, int top, int right, int bottom)const {
		return m_vSum[bottom + 1][right + 1] - m_vSum[top][right + 1] - m_vSum[bottom + 1][left] + m_vSum[top][left];
	}
	T GetTopLeft(int left, int top) { return Get(left, top, m_iColCnt - 1, m_iRowCnt - 1); }
	vector<vector<T>> m_vSum;
	const int m_iRowCnt, m_iColCnt;
};
class Solution {
public:
	int ways(vector<string>& pizza, int k) {
		m_iR = pizza.size();
		m_iC = pizza[0].size();
		CPreSum2<int> preSum(m_iR, m_iC, [&](int r, int c) {return 'A' == pizza[r][c]; });	
		m_dp.assign(k, vector<vector<C1097Int<>>>(m_iC, vector<C1097Int<>>(m_iR)));
		m_vHasDo.assign(k, vector<vector<bool>>(m_iC, vector<bool>(m_iR)));
		for (int left = 0; left < m_iC; left++) {
			for (int top = 0; top < m_iR; top++) {
				m_dp[0][left][top] = preSum.GetTopLeft(left, top)>0;
				m_vHasDo[0][left][top] = true;
			}
		}
		return Rec(preSum, pizza, k-1, 0, 0).ToInt();
	}
	C1097Int<> Rec( CPreSum2<int>& preSum,  vector<string>& pizza, int k, int left, int top) {
		auto& iRet = m_dp[k][left][top];
		if (m_vHasDo[k][left][top]) { return iRet; }
		m_vHasDo[k][left][top] = true;
		int cnt = preSum.Get(left, top, m_iC - 1, m_iR - 1);//当前蛋糕有多少苹果
		for (int x = left + 1; x <= m_iC - 1; x++) {//垂直切
			const int iSub = preSum.Get(left, top, x - 1, m_iR - 1);//送出多少苹果
			if (0 == iSub ) { continue; }
			if (cnt - iSub < k ) { continue; }
			iRet += Rec(preSum, pizza, k - 1, x, top);
		}
		for (int x = top + 1; x <= m_iR - 1; x++) {//水平切
			const int iSub = preSum.Get(left, top, m_iC - 1, x - 1);
			if (0 == iSub) { continue; }
			if (cnt - iSub < k) { continue; }
			iRet += Rec(preSum, pizza, k - 1, left, x);
		}
		return iRet;
	}
	vector<vector<vector<C1097Int<> >>> m_dp;
	vector<vector<vector<bool >>> m_vHasDo;
	int m_iR, m_iC;
};

VS自带单元测试

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;;
};

template<class T = int>
class CPreSum2 {
public:
	template<class _Pr>
	CPreSum2(int rowCnt, int colCount, _Pr pr):m_iRowCnt(rowCnt),m_iColCnt(colCount){
		m_vSum.assign(rowCnt + 1, vector<int>(colCount + 1));
		for (int r = 0; r < rowCnt; r++) {
			for (int c = 0; c < colCount; c++) {
				m_vSum[r + 1][c + 1] = m_vSum[r][c + 1] + m_vSum[r + 1][c] - m_vSum[r][c] + pr(r, c);
			}
		}
	}
	T Get(int left, int top, int right, int bottom)const {
		return m_vSum[bottom + 1][right + 1] - m_vSum[top][right + 1] - m_vSum[bottom + 1][left] + m_vSum[top][left];
	}
	T GetTopLeft(int left, int top) { return Get(left, top, m_iColCnt - 1, m_iRowCnt - 1); }
	vector<vector<T>> m_vSum;
	const int m_iRowCnt, m_iColCnt;
};
class Solution {
public:
	int ways(vector<string>& pizza, int k) {
		m_iR = pizza.size();
		m_iC = pizza[0].size();
		CPreSum2<int> preSum(m_iR, m_iC, [&](int r, int c) {return 'A' == pizza[r][c]; });	
		m_dp.assign(k, vector<vector<C1097Int<>>>(m_iC, vector<C1097Int<>>(m_iR)));
		m_vHasDo.assign(k, vector<vector<bool>>(m_iC, vector<bool>(m_iR)));
		for (int left = 0; left < m_iC; left++) {
			for (int top = 0; top < m_iR; top++) {
				m_dp[0][left][top] = preSum.GetTopLeft(left, top)>0;
				m_vHasDo[0][left][top] = true;
			}
		}
		return Rec(preSum, pizza, k-1, 0, 0).ToInt();
	}
	C1097Int<> Rec( CPreSum2<int>& preSum,  vector<string>& pizza, int k, int left, int top) {
		auto& iRet = m_dp[k][left][top];
		if (m_vHasDo[k][left][top]) { return iRet; }
		m_vHasDo[k][left][top] = true;
		int cnt = preSum.Get(left, top, m_iC - 1, m_iR - 1);//当前蛋糕有多少苹果
		for (int x = left + 1; x <= m_iC - 1; x++) {//垂直切
			const int iSub = preSum.Get(left, top, x - 1, m_iR - 1);//送出多少苹果
			if (0 == iSub ) { continue; }
			if (cnt - iSub < k ) { continue; }
			iRet += Rec(preSum, pizza, k - 1, x, top);
		}
		for (int x = top + 1; x <= m_iR - 1; x++) {//水平切
			const int iSub = preSum.Get(left, top, m_iC - 1, x - 1);
			if (0 == iSub) { continue; }
			if (cnt - iSub < k) { continue; }
			iRet += Rec(preSum, pizza, k - 1, left, x);
		}
		return iRet;
	}
	vector<vector<vector<C1097Int<> >>> m_dp;
	vector<vector<vector<bool >>> m_vHasDo;
	int m_iR, m_iC;
};

扩展阅读

视频课程

有效学习：明确的目标 及时的反馈 拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

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

相关下载

想高屋建瓴的学习算法，请下载《喜缺全书算法册》doc版
https://download.csdn.net/download/he_zhidan/88348653

我想对大家说的话
《喜缺全书算法册》以原理、正确性证明、总结为主。
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛

测试环境

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

闻缺陷则喜何志丹
关注
  • 36
    点赞
  • 踩
  • 48
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
用C语言实现Leetcode题目.zip
03-16
用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现Leetcode题目.zip用C语言实现...
leetcode和oj-leetcode:oj.leetcode.com中的问题及解决方案
06-30
1. 算法训练：LeetCode覆盖了排序、搜索、图论、动态规划等各种算法，通过实战练习，可以加深对算法的理解和应用。 2. 面试准备：许多公司在面试时会参考LeetCode上的问题，熟悉这些题目可以帮助求职者在面试中表现...
LeetCode 1444. 切披萨的方案数（一）
qq_45008831的博客
04-18 154
阴影部分是一刀切下后，能即刻分到的披萨，每次切需要保证即刻分得的披萨内部“A”的数量至少为1（“A”即Apple）。切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置，将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人，如果水平地切，那么需要把上面的部分送给一个人。dp[m][n][k]前两个维度是坐标，最后一个维度是cuts数，用来表示右下角的pizza切k cuts有多少种合法的切法。你需要切披萨 k-1 次，得到 k 块披萨并送给别人。
Leetcode 1444. 切披萨的方案数(DP,类似石材切割，二维前缀和）
菱形继承
05-11 667
1444. 切披萨的方案数 给你一个rows x cols大小的矩形披萨和一个整数 k，矩形包含两种字符：'A' （表示苹果）和'.'（表示空白格子）。你需要切披萨 k-1 次，得到k块披萨并送给别人。 切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置，将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人，如果水平地切，那么需要把上面的部分送给一个人。在切完最后一刀后，需要把剩下来的一块送给最后一个人。 请你返回确保每一块披萨包含至少一个苹...
Leetcode每日一题：1444. 切披萨的方案数（2023.8.17 C++）
Cosmoshhhyyy的博客
08-17 718
此题的关键是，dp[ k ][ i ][ j ] 的含义：代表还剩下 k 刀没切，剩下的是左上角为i ，j 的披萨状态时的切割方案总数。这是我自己的理解，力扣上dp数组定义的含义感觉不如我这样写和解释更直观，不过原理肯定是一样的。
LC-1444. 切披萨的方案数（记忆化搜索==＞动态规划）
qq_42958831的博客
08-17 130
困难118给你一个大小的矩形披萨和一个整数k，矩形包含两种字符：'A'（表示苹果）和'.'（表示空白格子）。你需要切披萨k-1次，得到k块披萨并送给别人。切披萨的每一刀，先要选择是向垂直还是水平方向切，再在矩形的边界上选一个切的位置，将披萨一分为二。如果垂直地切披萨，那么需要把左边的部分送给一个人，如果水平地切，那么需要把上面的部分送给一个人。在切完最后一刀后，需要把剩下来的一块送给最后一个人。请你返回确保每一块披萨包含一个苹果的切披萨方案数。
hackhu2019#LeetCode#LeetCode120. 三角形最小路径和1
07-25
1. 当前路径的最小值，为下一层左右两点的最小值加上当前坐标值// 处理空指针异常// 最底层数据长度// 存储下一层结果i++) { // 初始化最底层数据。
leetcode296-.leetcode:.leetcode
06-30
leetcode 296 .leetcode leetcode 刷题专用 日期 解决的题目 通过的提交 通过提交率 全站排名 2021/05/07 234/2074 381/601 63.39% 43409 2021/05/06 233/2073 380/600 63.33% 43607 2021/04/27 232/2063 379/599 63...
LeetCode 1392. 最长快乐前缀（KMP）
01-20
解释：不包括 s 自己，一共有 4 个前缀（l, le, lev, leve）和 4 个后缀（l, el, vel, evel）。 最长的既是前缀也是后缀的字符串是 l 。 示例 2： 输入：s = ababab 输出：abab 解释：abab 是最长的既是前缀也是后缀...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 864
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
2.6基本算法之动态规划6045:开餐馆
Andy_SCP001的博客
07-24 161
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
cf场+线性dp
xxx_jsu的博客
07-23 319
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
2766. 重新放置石块 Medium
珞米的博客
07-24 500
第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，有石块的位置为 [2,2,3,3]。第 i = 1 步操作中，我们将位置 3 处的石块移到位置 2 处，有石块的位置为 [2,2,2,2]。第 i = 0 步操作中，我们将位置 1 处的石块移到位置 2 处，位置 2,6,7,8 有石块。第 i = 1 步操作中，我们将位置 7 处的石块移到位置 9 处，位置 2,6,8,9 有石块。第 i = 2 步操作中，我们将位置 2 处的石块移到位置 5 处，位置 5,6,8,9 有石块。
代码随想录算法训练营第二十二天|回溯算法part01
最新发布
qq_43456971的博客
07-25 590
这一题与上题一样，除了终止条件中需要判断和是否为target。多了一个剪枝操作，就是当值已经大于target，直接返回。本题还有一个建立数字和字母之间映射的问题，使用string数组来进行映射。因此回溯算法的宽度是每个集合里面的个数，回溯算法的深度是集合的个数。参数是digits与index，index是用来记录遍历第几个集合。在单个集合1-9中，寻找所有个数为k且和为target的组合。在单个集合1-n中，寻找所有个数为k的组合。这一题是在多个集合中找所有可能的组合。和所有递归一样，都有三部曲。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 246
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
算法-KMP字符串匹配
xx_xb的博客
07-23 250
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
算法题目整合5
qq_62571233的博客
07-23 900
思路：利用left和right记录连续相同的字符串索引，计算长度len，如果是0,1,2,4这种情况直接输出-1并return。如果是奇数直接输出，如果是偶数的话，可以拆成3和len-3两个部分。的最小值是101100，求其第4554小即在从后数的四个问号位置分别加上‘3’，‘5’，‘5’，‘4’即可，即551153；表示当前卡牌正面（或反面）加上上一个取余结果再对3取余的值，举个例子，比如说。），由于不同的取余方案搭配上正反面的组合，共有6中结果，所以在。，表示当前卡牌正面为1，当遍历的。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 301
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
leetcode 2031. 1 比 0 多的子数组个数
12-16
leetcode 2031题是一道有关于子数组的问题。问题的要求是求出给定数组中，1的个数比0多的子数组的个数。我们可以通过遍历数组的每个元素，...以上就是针对leetcode 2031题的问题，求解1比0多的子数组个数的详细解答。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

闻缺陷则喜何志丹

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

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

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

打赏作者

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

抵扣说明：

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

余额充值