【动态规划】879. 盈利计划-编程知识

作者推荐

【动态规划】【广度优先搜索】【状态压缩】847 访问所有节点的最短路径

本文涉及知识点

动态规划汇总

LeetCode879. 盈利计划

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。
第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。
工作的任何至少产生 minProfit 利润的子集称为盈利计划。并且工作的成员总数最多为 n 。
有多少种计划可以选择？因为答案很大，所以返回结果模 10^9 + 7 的值。
示例 1：
输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。
示例 2：
输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。
参数：
1 <= n <= 100
0 <= minProfit <= 100
1 <= group.length <= 100
1 <= group[i] <= 100
profit.length == group.length
0 <= profit[i] <= 100

动态规划

动态规划的状态表示

pre[j][k]表示从前i个工作中，完成若干任务，出动了j人，利润为k的盈利计划数。例外：k==minProfit 时，包括利润大于minProfit的盈利计划数。

动态规划的转移方程

前i个任务，出动 preCount 人，利润为p
$\begin{cases} dp[preCount][p] += pre[preCount][p] & 不完成本任务 \\ 人数不足无法完成当前任务 & preCount+group[i] >n \\ dp[preCount+group[i]][min(minProfit,p+profit[i])] +=pre[preCount][p] & 完成本任务 \\ \end{cases}$

动态规划的初始值

pre[0][0]=1

动态规划的填表顺序

i从小到大

动态规划的返回值

$\sum\Large_{i:0 }^{pre.size()-1}$ v[i].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;}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 profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {vector<vector<C1097Int<>>> pre(n + 1, vector<C1097Int<>>(minProfit + 1));pre[0][0] = 1;for (int i = 0; i < group.size(); i++){auto dp = pre;//不完成当前任务for (int preCount = 0; preCount < n; preCount++){for (int p = 0; p <= minProfit; p++){const int iNewCount = preCount + group[i];if (iNewCount > n){continue;}const int iNewProfit = min(minProfit, p + profit[i]);dp[iNewCount][iNewProfit] += pre[preCount][p];}}pre.swap(dp);}C1097Int<> biRet;for (const auto& v : pre){biRet += v.back();}return biRet.ToInt();}
};

测试用例


template<class T>
void Assert(const T& t1, const T& t2)
{assert(t1 == t2);
}template<class T>
void Assert(const vector<T>& v1, const vector<T>& v2)
{if (v1.size() != v2.size()){assert(false);return;}for (int i = 0; i < v1.size(); i++){Assert(v1[i], v2[i]);}}int main()
{	int n,  minProfit;vector<int> group, profit;{Solution sln;n = 5, minProfit = 3, group = { 2, 2 }, profit = { 2, 3 };auto res = sln.profitableSchemes(n, minProfit, group, profit);Assert(res, 2);}{Solution sln;n = 10, minProfit = 5, group = { 2, 3, 5 }, profit = { 6, 7, 8 };auto res = sln.profitableSchemes(n, minProfit, group, profit);Assert(res, 7);}}

2023年 1月第一版

class CBigMath
{
public:
static void AddAssignment(int* dst, const int& iSrc)
{
*dst = (dst + iSrc) % s_iMod;
}
static void AddAssignment(int dst, const int& iSrc, const int& iSrc1)
{
*dst = (*dst + iSrc) % s_iMod;
*dst = (dst + iSrc1) % s_iMod;
}
static void AddAssignment(int dst, const int& iSrc, const int& iSrc1, const int& iSrc2)
{
*dst = (*dst + iSrc) % s_iMod;
*dst = (*dst + iSrc1) % s_iMod;
*dst = (dst + iSrc2) % s_iMod;
}
static void SubAssignment(int dst, const int& iSrc)
{
*dst = (s_iMod - iSrc + *dst) % s_iMod;
}
static int Add(const int& iAdd1, const int& iAdd2)
{
return (iAdd1 + iAdd2) % s_iMod;
}
static int Mul(const int& i1, const int& i2)
{
return((long long)i1 i2) % s_iMod;
}
private:
static const int s_iMod = 1000000007;
};
class Solution {
public:
int profitableSchemes(int n, int minProfit, vector& group, vector& profit) {
m_minProfit = minProfit;
vector pre((n + 1)(minProfit + 1));
pre[0] = 1;
int iMaxN = 0;
int iMaxProfit = 0;
for (int i = 0; i < group.size(); i++)
{
vector dp = pre;
for (int j = 0; j <= iMaxN; j++)
{
for (int k = 0; k <= iMaxProfit; k++)
{
const int iNewN = j + group[i];
if (iNewN > n)
{
//员工不足
continue;
}
const int iNewProfit = min(minProfit, k + profit[i]);
CBigMath::AddAssignment(&dp[GetIndex(iNewN, iNewProfit)], pre[GetIndex(j, k)]);
}
}
pre.swap(dp);
iMaxN = min(n, iMaxN + group[i]);
iMaxProfit = min(minProfit, iMaxProfit + profit[i]);
}
int iNum = 0;
for (int i = 0; i <= iMaxN; i++)
{
CBigMath::AddAssignment(&iNum ,pre[GetIndex(i, minProfit)]);
}
return iNum;
}
inline int GetIndex(int n, int pro)
{
return n *(m_minProfit + 1) + pro;
}
int m_minProfit;
};

2023年1月版

扩展阅读

视频课程

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

如何你想快

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

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛