Leetcode 简单线性递推：正反两种方法
这类问题，由于需要按顺序解决，所以排除排序+优先队列+贪心那一套；又不能是简单的贪心，因为某个问题是否选择解决，会影响后面可能得到的分数，所以很可能是个dp.
当然也有想排序再DP，但通常是线性的，线性的就有从前往后、从后往前两种顺序，通过都可以
LC 5982. Solving Questions With Brainpower
276场周赛第3题，差点翻车...
题意：有n个问题，只能依次解决，对于第i个问题，可以跳过，也可以选择解决，解决能获得questions[i][0]的分数，但是接下来的questions[i][1]个问题都不能做，求可以得到的最大分数。
方法：
先看一种直观点的：从后往前dp
方法一：倒序DP（查表）
定义：dp[i]表示后i个问题可以得到的最大分数
对于dp[i]，也就是对于第i个问题，
如果不选，dp[i] = dp[i-1]，因为没有选，最大的分数就和前面的相同
如果选，dp[i] = max(dp[i], dp[i+questions[i][1]+1] + questions[i][0]，因为接着的 questions[i][1] 个都不能选嘛
class Solution {
public:
long long mostPoints(vector<vector<int> >& questions) {
long long ans = 0;
int n = questions.size();
vector<long long>dp(n+1, 0);
dp[n-1] = questions[n-1][0];
for(int i = n-2;i >= 0;i--) {
if(i+questions[i][1] +1 < n) dp[i] = max(dp[i+1], dp[i+questions[i][1]+1] + questions[i][0]);
else dp[i] = max(dp[i+1], (long long)questions[i][0]);
}
return dp[0];
}
};
方法二：正向刷表
前面那种相当于递推，dp[i] 计算过程中要用到的值已经计算出来了，可以查表得到。
而正向是不断刷新dp数组，相当于计算每个问题的贡献。
参考 【解决智力问题】正向 DP
定义：dp[i]表示前i题的最大分数
选择跳过，不加此题得分，后续的题继承得分
选择做题，加上此题得分，跳过若干题后的下一题继承得分
class Solution {
public:
long long mostPoints(vector<vector<int>>& questions) {
int n = questions.size();
vector<long long> dp(n, 0);
for (int i = 0; i < n; i++) {
int next = i + 1;
if (next < n) dp[next] = max(dp[next], dp[i]);
next = i + questions[i][1] + 1;
dp[i] += questions[i][0]; //
if (next < n) dp[next] = max(dp[next], dp[i]);
}
long long ans = *max_element(dp.begin(), dp.end()); // 取dp中的最大值
return ans;
}
};
LC 1751. 最多可以参加的会议数目 II
方法：
与其他会议题不同，其他的都是指定范围选一个/k个点，这题是持续一段时间，如果开的话，接下来一段时间不能开其他会议
如果不开，dp[i][j] = dp[i-1][j]
如果开，dp[i][j] = dp[pre][j-1] + val，pre是小于 starttime[i] 的最大的endtime
上一题中，由于是连续的值，pre可以直接得到，这题中是离散的区间，endtime属于某个会议，由于最开始排序了，可以从后往前遍历，也可以二分查找。
class Solution {
public:
int maxValue(vector<vector<int>>& events, int k) {
int n = events.size();
sort(events.begin(), events.end(), [](const vector<int>& a, const vector<int>& b) {
if(a[1] == b[1]) return a[0] < b[0];
return a[1] < b[1];
}); // 按结束时间从小到大排序
vector<int>endtimes;
for(int i = 0;i < n;i++) endtimes.push_back(events[i][1]);
vector<vector<int>>dp(n+1, vector<int>(k+1, 0));
for(int i = 1;i <= n;i++) {
for(int j = 1;j <= k;j++) {
dp[i][j] = dp[i-1][j]; // 不开
int pre = lower_bound(endtimes.begin(), endtimes.end(), events[i-1][0]) - endtimes.begin() - 1;
// cout << "pre: " << pre << endl;
dp[i][j] = max(dp[i][j], dp[pre+1][j-1] + events[i-1][2]);
// cout << i << " " << j << " " << dp[i][j] << endl;
}
}
int ans = -1;
for(int i = 1;i <= k;i++) ans = max(ans, dp[n][i]);
return ans;
}
};
LC 1235. 规划兼职工作
题目：上一题的简化版，k=1的情况
方法：去掉一维，剩下一样
class Solution {
public:
int jobScheduling(vector<int>& startTime, vector<int>& endTime, vector<int>& profit) {
int n = startTime.size();
vector<vector<int>>jobs;
for(int i = 0;i < n;i++) {
jobs.push_back({startTime[i], endTime[i], profit[i]});
}
sort(jobs.begin(), jobs.end(), [](const vector<int>& a, const vector<int>& b){
return a[1] < b[1];
});
vector<int>myendtimes;
for(int i = 0;i < n;i++) myendtimes.push_back(jobs[i][1]);
vector<int>dp(n+1, 0);
for(int i = 1;i <= n;i++) {
dp[i] = dp[i-1]; // 不选
int pre = upper_bound(myendtimes.begin(), myendtimes.end(), jobs[i-1][0]) - myendtimes.begin() - 1;
dp[i] = max(dp[i], dp[pre+1] + jobs[i-1][2]);
}
return dp[n];
}
};
