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

本文涉及的基础知识点

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

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【ARM-Linux篇】u-boot编译

【ARM-Linux篇】u-boot编译

嵌入式Linux系统和PC完整的操作系统的对比如下&#xff1a; 一、u-boot简介 uboot是一种通用的引导加载程序&#xff0c;它可以用于多种嵌入式系统&#xff0c;支持多种操作系统&#xff0c;如Linux, Android,NetBSD等。uboot的主要作用是将操作系统内核从存储设备&#xff08…
阅读更多...
【Leetcode笔记】40.组合总和II

【Leetcode笔记】40.组合总和II

1. 题目要求 这道题目和39.组合总和不一样的地方在于&#xff1a;数组中含有相同的元素。同样地&#xff0c;结果不能含有重复组合。 拿第一个示例来看&#xff0c; candidates [1, 1, 2, 5, 6, 7, 10]问题在于&#xff1a;第一个path[1(index 0), 2]&#xff0c;绝不能出现…
阅读更多...
mysql实战——mysql主从复制管理

mysql实战——mysql主从复制管理

一、常见的管理操作 1、查看主库状态 show master status 2、查看从库复制的状态 show slave status 3、在主库上查看从库ip和端口信息 show processlist show slave hosts 4、reset slave、reset master、reset slave all 1、reset master 该命令会执行以下操作&#xff…
阅读更多...
JS对象由浅入深

JS对象由浅入深

对象 对象&#xff08;Object&#xff09;&#xff1a;JavaScript里的一种数据类型&#xff08;引用类型&#xff09;&#xff0c;也是用于存储数据的 好处&#xff1a;可以用来详细的描述某个事物&#xff0c;是用键值对形式存储语义更明了 特点&#xff1a;对象数据是无序的&…
阅读更多...
C++程序命令行参数学习

C++程序命令行参数学习

argc是参数个数&#xff1b; argv[0]是程序名&#xff0c;argv[1]是第一个参数&#xff1b; 如果输入osgptr1 x &#xff0c;osgptr1是程序名&#xff0c;argc是2&#xff1b; 不算程序名&#xff0c;实际的参数个数是argc-1&#xff1b; #include <iostream>using …
阅读更多...
Microsoft Fabric 是什么？

Microsoft Fabric 是什么？

最近半个月没有更新内容&#xff0c;原因是什么呢&#xff1f; 原因是花了两周的时间备考了一下"Microsoft Certified: Fabric Analytics Engineer Associate"的考试认证。 非常幸运考试通过了。 那什么是Microsoft Fabric 呢&#xff1f; Microsoft Fabric 是一个…
阅读更多...
统信UOS SSH服务升级（ubuntu20）内网

统信UOS SSH服务升级（ubuntu20）内网

服务器配置 系统信息 SSH版本 目标版本 openssh-server_8.2p1-4_arm64.deb 因为不通互联网&#xff0c;所以所有deb包需要手动下载&#xff08;可以连接互联网的可以自动忽略手动下载deb步骤&#xff0c;直接apt-get install xxx 即可&#xff09; 升级步骤 !!!deb下载方式…
阅读更多...
Vue.js - 生命周期与工程化开发【0基础向 Vue 基础学习】

Vue.js - 生命周期与工程化开发【0基础向 Vue 基础学习】

文章目录 Vue 的生命周期Vue 生命周期的四个阶段Vue 生命周期函数&#xff08;钩子函数 工程化开发 & 脚手架 Vue CLI**开发 Vue 的两种方式&#xff1a;**脚手架目录文件介绍项目运行流程组件化开发 & 根组件App.vue 文件&#xff08;单文件组件&#xff09;的三个组成…
阅读更多...
【JMeter接口自动化】第2讲 Jmeter目录结构

【JMeter接口自动化】第2讲 Jmeter目录结构

JMeter的目录结构如下&#xff1a; bin目录&#xff1a;可执行文件目录&#xff0c;启动jmeter时&#xff0c;就是启动bin目录下的ApacheJmeter.jar&#xff0c;jmeter.bat&#xff0c;jmeter.sh ApacheJmeter.jar:启动文件 jmeter.bat&#xff1a;Windows 的启动命令。 jmeter…
阅读更多...
【Leetcode每日一题】 综合练习 - 组合（难度⭐⭐）（78）

【Leetcode每日一题】 综合练习 - 组合（难度⭐⭐）（78）

1. 题目解析 题目链接&#xff1a;77. 组合 这个问题的理解其实相当简单&#xff0c;只需看一下示例&#xff0c;基本就能明白其含义了。 2.算法原理 题目要求我们从 1 到 n 的整数集合中选择 k 个数的所有组合&#xff0c;且组合中的元素不考虑顺序。这意味着集合 [1, 2] 和…
阅读更多...
控制障碍函数CBF详解（附带案例实现）

控制障碍函数CBF详解（附带案例实现）

控制障碍函数CBF详解&#xff08;附带案例实现&#xff09; 文章目录 控制障碍函数CBF详解&#xff08;附带案例实现&#xff09;1. Control Affine System2. Lyapunov Theory, Nagumos Theory, Invariance Principle3. Control Lyapunov Function (CLF) and CLF-QP4. Control …
阅读更多...
Nginx实战：LUA脚本_环境配置安装

Nginx实战：LUA脚本_环境配置安装

目录 一、什么是LUA脚本 二、Nginx中的LUA脚本 1、主要特点 2、用途 三、如何在nginx中使用LUA脚本 1、原生nginx 2、OpenResty 3、nginx lua配置验证 一、什么是LUA脚本 Nginx Lua 脚本是 Nginx 与 Lua 语言集成的结果&#xff0c;它允许你使用 Lua 语言编写Nginx 模块…
阅读更多...
521源码-源码下载-个人网盘源码2024最新web网盘系统源码一键安装版源码分享

521源码-源码下载-个人网盘源码2024最新web网盘系统源码一键安装版源码分享

主要功能&#xff1a; 1.支持用户管理系统。支持用户注册功能&#xff08;后台可关闭&#xff09;&#xff0c;管理可为每个用户分配一定数额的存储空间&#xff0c;还可以限制单个上传文件大小。 2.支持管理员查看每个会员的文件上传、分享情况&#xff0c;可对用户文件进行删…
阅读更多...
YOLOv8 多种任务网络结构详细解析 | 目标检测、实例分割、人体关键点检测、图像分类

YOLOv8 多种任务网络结构详细解析 | 目标检测、实例分割、人体关键点检测、图像分类

前言 本文仅根据模型的预测过程&#xff0c;即从输入图像到输出结果&#xff08;图像预处理、模型推理、后处理&#xff09;&#xff0c;来展现不同任务下的网络结构&#xff0c;OBB 任务暂不包含。 Backbone 1. yolov8m 2. yolov8m-p2 3. yolov8m-p6 4. 细节 图中 CBS Con…
阅读更多...
2024 HN CTF WebMisc 部分 wp

2024 HN CTF WebMisc 部分 wp

Web ez_tp 判断是thinkphp 3.2 参考官方手册:https://www.kancloud.cn/manual/thinkphp/1697 判断路由模式 URL_CASE_INSENSITIVE > true, // 默认false 表示URL区分大小写 true则表示不区分大小写URL_MODEL > 1, // URL访问模式,可选参数0、1、…
阅读更多...
【Linux-buildroot,】

【Linux-buildroot,】

Linux-buildroot, ■ buildroot■ 1、简介■ 2、下载■ 2、编译■ 问题一&#xff1a;buildroot 编译的时候会先从网上下载所需的软件源码&#xff0c;下载cmake-3.8.2.tar.gz或下载很慢的情况 ■ buildroot-构建根文件系统■ 1、配置 buildroot■ 2、■ 3、 ■ buildroot-构建…
阅读更多...
velero实现备份还原

velero实现备份还原

Velero 是一个开源的 Kubernetes 集群备份和恢复工具&#xff0c;它允许用户轻松安全地备份和恢复他们的 Kubernetes 资源和持久化卷。Velero 由 Kubernetes 的原生 API 驱动&#xff0c;并且与云服务提供商紧密集成&#xff0c;以支持不同的存储解决方案。 helm values文件地…
阅读更多...
驾校无线监控系统：实现智能化、数字化与网络化的新篇章

驾校无线监控系统：实现智能化、数字化与网络化的新篇章

随着科技的飞速发展&#xff0c;无线监控系统在各行各业的应用日益广泛。在驾校领域&#xff0c;无线监控系统的引入不仅提升了学员的学习体验&#xff0c;还显著提高了驾校的管理效率和综合水平。本文将详细探讨驾校无线监控系统的功能、优势及其在提升驾校管理水平方面的具体…
阅读更多...
如何看待时间序列与机器学习？

如何看待时间序列与机器学习？

GPT-4o 时间序列与机器学习的关联在于&#xff0c;时间序列数据是一种重要的结构化数据形式&#xff0c;而机器学习则是一种强大的工具&#xff0c;用于从数据中提取有用的模式和信息。在很多实际应用中&#xff0c;时间序列与机器学习可以结合起来&#xff0c;发挥重要作用。…
阅读更多...
考研回顾纪录--科软考研失败并调剂兰州大学软件工程专业复试经历

考研回顾纪录--科软考研失败并调剂兰州大学软件工程专业复试经历

1.背景 本人工作一年后决定考研&#xff0c;遂于2023年4月底离职。5月到家后开始学习。本科东北大学软件工程专业&#xff0c;绩点3.2/5&#xff0c;按照百分制计算是82分。本科纯属混子&#xff0c;只有一个四级551&#xff0c;一个数学竞赛省二等奖&#xff0c;大创学校立项…
阅读更多...
最新文章

Copyright @ 2022~2023