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

news2024/11/18 16:31:17

本文涉及的基础知识点

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++**实现。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1720862.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

生成式AI，在云端的绽放与盛开

生成式AI，在云端的绽放与盛开

编辑&#xff1a;阿冒 设计&#xff1a;沐由 毫无疑问&#xff0c;生成式AI已然成为当今技术发展和应用创新的重要引擎之一。 过去的一年多时间里&#xff0c;我们每个人都在目睹和见证着生成式AI是如何以移山倒海的力量&#xff0c;为诸多行业带来革命性乃至颠覆性的变革&…
阅读更多...
Python3位运算符

Python3位运算符

前言 本文介绍的是位运算符&#xff0c;位运算可以理解成对二进制数字上的每一个位进行操作的运算&#xff0c;位运算分为 布尔位运算符 和 移位位运算符。 文章目录 前言一、位运算概览1、布尔位运算符1&#xff09;按位与运算符 ( & )2&#xff09;按位或运算符 ( | )3…
阅读更多...
输入输出安全防护指南

输入输出安全防护指南

输入输出安全防护指南 在现代网络应用程序中&#xff0c;输入输出的安全性是至关重要的。未经验证的输入和未编码的输出可能导致严重的安全漏洞&#xff0c;如SQL注入、跨站脚本攻击&#xff08;XSS&#xff09;等。本文将详细讨论如何通过输入验证和输出编码来确保应用程序的…
阅读更多...
9. C++通过epoll+fork的方式实现高性能网络服务器

9. C++通过epoll+fork的方式实现高性能网络服务器

epollfork 实现高性能网络服务器 一般在服务器上&#xff0c;CPU是多核的&#xff0c;上述epoll实现方式只使用了其中的一个核&#xff0c;造成了资源的大量浪费。因此我们可以将epoll和fork结合来实现更高性能的网络服务器。 创建子进程函数–fork( ) 要了解线程我们先来了解…
阅读更多...
零配件相关销售业务

零配件相关销售业务

测试场景CRM订单类型描述SAP订单类型描述发货开票备注零部件销售&退货服务商零配件订单标准订单&#xff08;服务商零配件&#xff09;参考DN开票YY　服务商零配件退货单退货订单(服务商零配件&#xff09;不开票退返账号金额YN服务商收到的零配件&#xff08;不能使用&…
阅读更多...
Charles-ios无法抓包原因之一证书

Charles-ios无法抓包原因之一证书

VPN证书安装完成后依然无法抓包存在无网络问题 VPN安装证书后直接抓包这时候抓包接口返回无网络&#xff0c;原因是IOS通用-关于本机-证书信任设计未开启信任
阅读更多...
最佳实践：REST API 的 HTTP 请求参数

最佳实践：REST API 的 HTTP 请求参数

HTTP 请求中的请求参数解释 当客户端发起 HTTP 请求 时&#xff0c;它们可以在 URL 末尾添加请求参数&#xff08;也叫查询参数或 URL 参数&#xff09;来传递数据。这些参数以键值对的形式出现在 URL 中&#xff0c;方便浏览和操作。 请求参数示例 以下是一些带有请求参数的…
阅读更多...
c基础 - 输入输出

c基础 - 输入输出

目录 一.scanf() 和 printf() 函数 1.printf 2.scanf 二 . getchar() & putchar() 函数 1.int getchar(void) 2.int putchar(int c) 三. gets() & puts() 函数 一.scanf() 和 printf() 函数 #include <stdio.h> 需要引入头文件,stdio.h 1.printf print…
阅读更多...
【Linux】权限的概念

【Linux】权限的概念

1.Linux权限的概念 Linux下有两种用户&#xff1a;超级用户&#xff08;root&#xff09;、普通用户。 超级用户&#xff1a;可以再linux系统下做任何事情&#xff0c;不受权限限制 普通用户&#xff1a;在linux下做有限的事情&#xff0c;受权限设置。 windows下也有超级用户…
阅读更多...
ADC数模转换器

ADC数模转换器

一、ADC&#xff08;Analog-Digital Converter&#xff09;模拟-数字转换器 1、ADC可以将引脚上连续变化的模拟电压转换为内存中存储的数字变量&#xff0c;建立模拟电路到数字电路的桥梁 2、12位逐次逼近型ADC&#xff0c;1us转换时间 3、输入电压范围&#xff1a;0~3.3V&a…
阅读更多...
掌握 JavaScript 基本输出方法

掌握 JavaScript 基本输出方法

掌握 JavaScript 基本输出方法 前言 这是我在这个网站整理的笔记,有错误的地方请指出&#xff0c;关注我&#xff0c;接下来还会持续更新。 作者&#xff1a;神的孩子都在歌唱 JavaScript 是一种强大且灵活的编程语言&#xff0c;广泛用于 Web 开发。通过 JavaScript&#xff…
阅读更多...
2.2 Docker安装redis

2.2 Docker安装redis

2.2 Docker安装redis 1.安装redis docker run --restartalways -p 6379:6379 --name myredis -d redis:7.0.12 --requirepass Hgh675667%–restartalways 开机自启动 -p 6379:6379 端口映射 –name myredis 容器名称 -d redis:7.0.12 redis版本 –requirepass Hgh675667% 密…
阅读更多...
异常处理1--5.31

异常处理1--5.31

try--catch--finally格式&#xff1a; try{ }catch(错误类型){ }finally{ } 执行情况&#xff1a; package javatest5;public class test {public static void main(String[] args) {int num115;int num20;try{System.out.println("商等于&#xff1a;"num1/num…
阅读更多...
JVM学习-类加载过程(二)

JVM学习-类加载过程(二)

Initialization初始化阶段 为类的静态变量赋予正确的初始值 具体描述 类的初始化是类装载的最后一个阶段&#xff0c;如果前面的步骤没有问题&#xff0c;那么表示类可以顺利装载到系统中&#xff0c;此时&#xff0c;类才会开始执行Java字节码(即&#xff0c;到了初始化阶段…
阅读更多...
龙芯3A4000+FPGA云终端解决方案，搭载昆仑国产化固件,支持UOS、银河麒麟等国产操作系统

龙芯3A4000+FPGA云终端解决方案，搭载昆仑国产化固件,支持UOS、银河麒麟等国产操作系统

龙芯云终端基于国产化龙芯高性能四核3A4000处理器平台的国产自主可控解决方案&#xff0c;搭载昆仑国产化固件,支持UOS、银河麒麟等国产操作系统&#xff0c;满足国产化信息安全运算的需求&#xff0c;实现从硬件、操作系统到应用的完全国产、自主、可控&#xff0c;是国产信息…
阅读更多...
AI 赋能前端 -- 文本内容概要生成

AI 赋能前端 -- 文本内容概要生成

幸福不在于你获得了什么，而在于你比他人多获得了什么 是比较出来的 大家好，我是柒八九。一个专注于前端开发技术/Rust及AI应用知识分享的Coder 此篇文章所涉及到的技术有 OpenAILangChainRust/WebAssemblyWeb Workerreact+ts+vite配置环境变量(env)因为，行文字数所限，有些概…
阅读更多...
常用电机测试方法的介绍与功能实现（M测试方法）

常用电机测试方法的介绍与功能实现（M测试方法）

目录 概述 1 常用电机测速方法简介 1.1 方法概览 1.2 编码器测速方法 2 M法测速 2.1 理论描述 2.2 实现原理 2.3 速度计算方法 3 功能实现 3.1 功能介绍 3.2 代码实现 3.2.1 使用STM32Cube配置参数 3.2.2 脉冲计数功能 3.2.3 测速函数 4 测试 概述 本文主要介绍…
阅读更多...
Mybatis-plus 更新或新增时设置某些字段值为空

Mybatis-plus 更新或新增时设置某些字段值为空

方式一 在实体中设置某个字段为的注解中 TableField(updateStrategy FieldStrategy.IGNORED)private Date xxxxxxTime;通过这种方式会指定更新时该字段的策略&#xff0c;通常情况下updateById这种会根据字段更新&#xff0c;通常都会判断null 以及空值 指定 updateStrategy …
阅读更多...
521源码网-免费网络教程-Cloudflare使用加速解析-优化大陆访问速度

521源码网-免费网络教程-Cloudflare使用加速解析-优化大陆访问速度

Cloudfalre 加速解析是由 心有网络 向中国大陆用户提供的公共优化服务 接入服务节点: cf.13d7s.sit 接入使用方式类似于其它CDN的CNAME接入&#xff0c;可以为中国大陆用户访问Cloudflare网络节点大幅度加速&#xff0c;累计节点130 如何接入使用 Cloudflare 加速解析&#…
阅读更多...
某咨询公司的大数据解决方案介绍（32页PPT）

某咨询公司的大数据解决方案介绍（32页PPT）

方案介绍&#xff1a; 本咨询公司的大数据平台解决方案以企业实际需求为出发点&#xff0c;结合先进的大数据技术和行业经验&#xff0c;为企业提供一站式的大数据服务。通过实时数据收集与处理、深度数据分析与挖掘、可视化数据展示以及灵活的数据应用与扩展&#xff0c;帮助…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023