算法篇：动态规划I
声明：若未特殊标出，则默认是leedcode原题。
1、1137.第N个泰波那契数列：
①状态表示：dp[i]表示：第i个泰波那契数的值。
②状态转移方程：以i位置的状态，最近的一步，来划分问题：dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
③初始化：dp[0] = 0 dp[1] = dp[2] = 1
④填表顺序：从左往右。
⑤返回值：dp[n]
class Solution
{
public:
int tribonacci(int n)
{
// 0、处理边界情况
if(n == 0) return 0;
if(n == 1 || n == 2) return 1;
// 1、创建dp表
vector dp(n+1);
// 2、初始化
dp[0] = 0, dp[1] = dp[2] = 1;
// 3、填表
for(int i = 3; i <= n; i++)
{
dp[i] = dp[i-1] + dp[i-2] + dp[i-3];
}
// 4、返回值
return dp[n];
}
}; 利用滚动数组优化：
class Solution
{
public:
int tribonacci(int n)
{
if(n == 0) return 0;
if(n == 1 || n == 2) return 1;
int a = 0, b = 1, c = 1, d;
for(int i = 3; i <= n; i++)
{
d = a + b + c;
// 滚动操作
a = b; b = c; c = d;
}
return d;
}
};2、面试题 08.01.三步问题
①状态表示：dp[i]表示到达i位置时，一共有多少种方法。
②状态转移方程：以i位置的状态，最近的一步，来划分问题：dp[i] = dp[i-1] + dp[i-2] + dp[i-3]
③初始化：dp[1] = 1 dp[2] = 2 dp[3] = 4
④填表顺序：从左往右。
⑤返回值：dp[n]
class Solution
{
public:
int waysToStep(int n)
{
// 0、处理边界情况
if(n == 0) return 0;
if(n == 1) return 1;
if(n == 2) return 2;
if(n == 3) return 4;
const int MOD = 1e9 + 7;
// 1、创建dp表
vector dp(n+1);
// 2、初始化
dp[0] = 0, dp[1] = 1, dp[2] = 2, dp[3] = 4;
// 3、填表
for(int i = 4; i <= n; i++)
{
dp[i] = ((dp[i-1] + dp[i-2]) % MOD + dp[i-3]) % MOD;
}
// 4、返回值
return dp[n];
}
} 3、746.使用最小花费爬楼梯
解法一：
①状态表示：dp[i]表示到达i位置时，最小花费。
②状态转移方程：用之前/之后的状态，推导出dp[i]的值。根据最近的一步，来划分问题：
先到达i-1位置，然后支付cost[i-1]，走一步：dp[i] = dp[i-1] + cost[i-1]
先到达i-2位置，然后支付cost[i-2]，走两步：dp[i] = dp[i-2] + cost[i-2]
dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);
③初始化：保证填表时不越界：dp[0] = dp[1] = 0
④填表顺序：从左往右。
⑤返回值：dp[n]
class Solution
{
public:
int minCostClimbingStairs(vector& cost)
{
// 1、创建dp表
int n = cost.size();
vector dp(n+1);
// 2、初始化(vector默认初始值为0)
// dp[0] = dp[1] = 0;
// 3、填表
for(int i = 2; i <= n; i++)
{
dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);
}
// 4、返回值
return dp[n];
}
}; 解法二：
①状态表示：从i位置出发，到达楼顶，此时的最小花费。
②状态转移方程：用之前/之后的状态，推导出dp[i]的值。根据最近的一步，来划分问题：
支付cost[i]，走一步，到达i+1位置出发到终点：dp[i] = dp[i+1] + cost[i]
支付cost[i]，走两步，到达i+2位置出发到终点：dp[i] = dp[i+2] + cost[i]
dp[i] = min(dp[i+1] + cost[i], dp[i+2] + cost[i]);
③初始化：保证填表时不越界：dp[n-1] = cost[n-1] dp[n-2] = cost[n-2]
④填表顺序：从右往左。
⑤返回值：min(dp[0]，dp[1])
class Solution
{
public:
int minCostClimbingStairs(vector& cost)
{
// 1、创建dp表
int n = cost.size();
vector dp(n);
// 2、初始化
dp[n-1] = cost[n-1], dp[n-2] = cost[n-2];
// 3、填表
for(int i = n - 3; i >= 0; i--)
dp[i] = cost[i] + min(dp[i+1], dp[i+2]);
// 4、返回值
return min(dp[0], dp[1]);
}
}; 4、91.解码方法
①状态表示：dp[i]表示到达i位置时，解码方法的总数。
②状态转移方程：根据最近的一步，来划分问题：
s[i]单独解码： 成功（1<=a<=9)：dp[i-1] 失败：0
s[i-1]与s[i]解码：成功（10<=b*10+a<=26)：dp[i-2] 失败：0
dp[i] = dp[i-1] + dp[i-2]
③初始化：dp[0] =0/1 dp[1] = 0/1/2
④填表顺序：从左往右。
⑤返回值：dp[n-1]
class Solution
{
public:
int numDecodings(string s)
{
// 1、创建dp表
int n = s.size();
vector dp(n);
// 2、初始化
dp[0] = s[0] != '0';
if(n == 1 || dp[0] == 0) return dp[0]; // 处理边界情况
if(s[0] != 0 && s[1] != '0') dp[1] += 1;
int t = (s[0] - '0') * 10 + s[1] - '0';
if(t >= 10 && t <= 26) dp[1] += 1;
// 3、填表
for(int i = 2; i < n; i++)
{
if(s[i] != '0') dp[i] += dp[i-1];
int q = (s[i-1] - '0') * 10 + s[i] - '0';
if(q >= 10 && q <= 26) dp[i] += dp[i-2];
}
// 4、返回值
return dp[n-1];
}
}; 优化原理：处理边界问题以及初始化问题的技巧（虚拟节点）
注意事项：
①虚拟节点里面的值，要保证后面的填表是正确的。
②下标的映射关系。
class Solution
{
public:
int numDecodings(string s)
{
// 优化
// 1、创建dp表
int n = s.size();
vector dp(n + 1);
// 2、初始化
dp[0] = 1;
dp[1] = s[1 - 1] != '0';
// 3、填表
for(int i = 2; i <= n; i++)
{
if(s[i - 1] != '0') dp[i] += dp[i - 1];
int t = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
if(t >= 10 && t <= 26) dp[i] += dp[i - 2];
}
// 4、返回值
return dp[n];
}
}; 5、62.不同路径
①状态表示：dp[i][j]表示到达[i,j]位置时，一共有多少种方式。
②状态转移方程：根据最近的一步，来划分问题：
从[i-1,j]→[i,j]→dp[i-1][j]
从[i,j-1]→[i,j]→dp[i][j-1]
dp[i][j] = dp[i-1][j] + dp[i][j-1]
③初始化：增添一行和一列的虚拟节点。
④填表顺序：从上往下填写每一行，每一行从左往右。
⑤返回值：dp[m][n]
class Solution
{
public:
int uniquePaths(int m, int n)
{
// 1、创建dp表
vector> dp(m + 1, vector(n + 1));
// 2、初始化
dp[0][1] = 1;
// 3、填表
for(int i = 1; i <= m; i++)
{
for(int j = 1; j <= n; j++)
{
dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
// 4、返回值
return dp[m][n];
}
}; 6、63.不同路径II(有障碍物）
class Solution
{
public:
int uniquePathsWithObstacles(vector>& ob)
{
// 1、创建dp表
int m = ob.size(), n = ob[0].size();
vector> dp(m + 1, vector(n + 1));
// 2、初始化
dp[0][1] = 1;
// 3、填表
for(int i = 1; i <= m; i++)
{
for(int j = 1; j <= n; j++)
{
if(ob[i - 1][j - 1] == 0) dp[i][j] = dp[i-1][j] + dp[i][j-1];
}
}
// 4、返回值
return dp[m][n];
}
}; 8、931.下降路径最小和
①状态表示：dp[i][j]表示到达[i,j]位置时，最小的下降路径。
②状态转移方程：根据最近的一步，来划分问题：
从[i-1,j-1]→[i,j]→x=dp[i-1][j-1]+m[i][j]
从[i-1, j ]→[i,j]→y=dp[i-1][ j ]+m[i][j]
从[i-1,j+1]→[i,j]→z=dp[i-1][j+1]+m[i][j]
dp[i][j] = min(x,y,z)+m[i][j]
③初始化：增添一行和两列虚拟节点，所有位置填正无穷，第一行改为0。
④填表顺序：从上往下填写每一行。
⑤返回值：最后一行最小值。
class Solution
{
public:
int minFallingPathSum(vector>& matrix)
{
int n = matrix.size();
// 1、创建dp表
vector> dp(n + 1, vector(n + 2, INT_MAX));
// 2、初始化第一行
for(int j = 0; j <= n + 1; j++) dp[0][j] = 0;
// 3、填表
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++)
dp[i][j] = min(dp[i-1][j-1], min(dp[i-1][j], dp[i-1][j+1])) + matrix[i - 1][j - 1];
int ret = INT_MAX;
// 4、返回值
for(int j = 1; j <= n; j++)
ret = min(ret, dp[n][j]);
return ret;
}
}; 10、174.地下城游戏（有后效性）
①状态表示：
错误状态表示：dp[i][j]表示从起点出发，到达[i,j]位置时，所需最低初始健康点数。（以某位置为结尾）
正确状态表示：dp[i][j]表示从[i,j]位置出发，到达终点时，所需最低初始健康点数。（以某位置为起点）
②状态转移方程：根据最近的一步，来划分问题：
向右走：dp[i][j]=dp[i][j+1]-d[i][j]
向下走：dp[i][j]=dp[i+1][j]-d[i][j]
dp[i][j] = min(dp[i][j+1]，dp[i+1][j])-d[i][j]，由于最低健康点数为1，故dp[i][j]=max(1,dp[i][j])。
③初始化：最右和最下面分别增添一列/行虚拟节点，保证最低健康血量为1，其余填正无穷大即可。
④填表顺序：从下往上填写每一行，每一行从右往左。
⑤返回值：dp[0][0]
class Solution
{
public:
int calculateMinimumHP(vector>& dungeon)
{
int m = dungeon.size(), n = dungeon[0].size();
// 1、创建dp表
vector> dp(m + 1, vector(n + 1, INT_MAX));
// 2、初始化
dp[m-1][n] = dp[m][n-1] = 1;
// 3、填表
for(int i = m - 1; i >= 0; i--)
for(int j = n - 1; j >=0; j--)
dp[i][j] = max(1, min(dp[i][j + 1], dp[i + 1][j]) - dungeon[i][j]);
// 4、返回值
return dp[0][0];
}
}; 11、打家劫舍I：按摩师
①状态表示：选择到i位置的时候，此时的最长预约时长。
f[i]表示：选择到i位置的时候，nums[i]必选，此时的最长预约时长。
g[i]表示：选择到i位置的时候，nums[i]不选，此时的最长预约时长。
②状态转移方程：
i处选： f[i]=g[i-1]+nums[i]
i处不选：i-1处选： g[i]=f[i-1]
i-1处不选：g[i]=g[i-1]
g[i]=max(f[i-1],g[i-1])
③初始化：此处没有必要加虚拟节点，f[0]=nums[0]，g[0]=0。
④填表顺序：从左往右，两个表一起填。
⑤返回值：max(f[n-1],g[n-1])
class Solution
{
public:
int massage(vector& nums)
{
// 0、处理边界条件
int n = nums.size();
if(n == 0) return 0;
// 1、创建dp表
vector f(n), g(n);
// 2、初始化
f[0] = nums[0];
// 3、填表
for(int i = 1; i < n; i++)
{
f[i] = g[i - 1] + nums[i];
g[i] = max(f[i - 1],g[i - 1]);
}
// 4、返回值
return max(f[n - 1],g[n - 1]);
}
}; 12、213.打家劫舍II
①状态表示：通过分类讨论，将环形的问题，转化成两个线性的“打家劫舍I”。
f[i]表示：偷到i位置时，偷nums[i]，此时的最大金额。
g[i]表示：偷到i位置时，不偷nums[i]，此时的最大金额。
②状态转移方程：
i处偷： f[i]=g[i-1]+nums[i]
i处不偷：i-1处偷： g[i]=f[i-1]
i-1处不偷：g[i]=g[i-1]
g[i]=max(f[i-1],g[i-1])
③初始化：此处没有必要加虚拟节点，f[0]=nums[0]，g[0]=0。
④填表顺序：从左往右，两个表一起填。
⑤返回值：max(f[n-1],g[n-1])
class Solution
{
public:
int rob(vector& nums)
{
int n = nums.size();
return max(nums[0] + rob1(nums, 2, n - 2), rob1(nums, 1, n - 1));
}
int rob1(vector& nums, int left, int right)
{
// 0、处理边界条件
if(left > right) return 0;
int n = nums.size();
// 1、创建dp表
vector f(n), g(n);
// 2、初始化
f[left] = nums[left];
// 3、填表
for(int i = left + 1; i <= right; i++)
{
f[i] = g[i - 1] + nums[i];
g[i] = max(f[i - 1],g[i - 1]);
}
// 4、返回值
return max(f[right], g[right]);
}
}; 13、740.删除并获得点数
①状态表示：预处理：将数组中的数，统计到arr中，做一次“打家劫舍I”问题即可。
②状态转移方程：
i处选： f[i]=g[i-1]+arr[i]
i处不选：i-1处选： g[i]=f[i-1]
i-1处不选：g[i]=g[i-1]
g[i]=max(f[i-1],g[i-1])
③初始化：此处没有必要加虚拟节点，f[0]=arr[0]，g[0]=0。
④填表顺序：从左往右，两个表一起填。
⑤返回值：max(f[n-1],g[n-1])
class Solution
{
public:
int deleteAndEarn(vector& nums)
{
const int N = 10001;
// 0、预处理
vector arr(N);
for(auto x : nums) arr[x] += x;
// 1、创建dp表
vector f(N), g(N);
// 2、初始化
f[0] = arr[0];
// 3、填表
for(int i = 1; i < N; i++)
{
f[i] = g[i - 1] + arr[i];
g[i] = max(f[i - 1],g[i - 1]);
}
// 4、返回值
return max(f[N - 1],g[N - 1]);
}
}; 14、LCR 091.粉刷房子
①状态表示：
dp[i][0]表示：粉刷到i位置时，粉刷上红色，此时的最小花费。
dp[i][1]表示：粉刷到i位置时，粉刷上蓝色，此时的最小花费。
dp[i][2]表示：粉刷到i位置时，粉刷上绿色，此时的最小花费。
②状态转移方程：
dp[i][0]=min(dp[i-1][1],dp[i-1][2])+costs[i][0]
dp[i][1]=min(dp[i-1][0],dp[i-1][2])+costs[i][1]
dp[i][2]=min(dp[i-1][0],dp[i-1][1])+costs[i][2]
③初始化：加一列虚拟节点并初始化为0。
④填表顺序：从左往右，三个表一起填。
⑤返回值：min(dp[n][0],dp[n][1],dp[n][2])
class Solution
{
public:
int minCost(vector>& costs)
{
// 1、创建dp表
int n = costs.size();
vector> dp(n + 1, vector(3));
// 2、初始化
// 3、填表
for(int i = 1; i <= n; i++)
{
dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + costs[i - 1][0];
dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + costs[i - 1][1];
dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + costs[i - 1][2];
}
// 4、返回值
return min(dp[n][0], min(dp[n][1], dp[n][2]));
}
}; 15、309.买卖股票的最佳时期I（含冷冻期）
①状态表示：
dp[i][0]表示：第i天结束后，处于“买入”状态，此时的最大利润。
dp[i][1]表示：第i天结束后，处于“可交易”状态，此时的最大利润。
dp[i][2]表示：第i天结束后，处于“冷冻期”状态，此时的最大利润。
②状态转移方程：（状态机）
dp[i][0]=max(dp[i-1][0],dp[i-1][0]-prices[i-1])
dp[i][1]=max(dp[i-1][1],dp[i-1][2])
dp[i][2]=dp[i-1][0]+prices[i]
③初始化：dp[0][0]=-p[0] dp[0][1]=0 dp[0][2]=0
④填表顺序：从左往右，三个表一起填。
⑤返回值：max(dp[n-1][1],dp[n-1][2])
class Solution
{
public:
int maxProfit(vector& prices)
{
// 1、创建dp表
int n = prices.size();
vector> dp(n, vector(3));
// 2、初始化
dp[0][0]=-prices[0];
// 3、填表
for(int i = 1; i < n; i++)
{
dp[i][0]=max(dp[i - 1][0], dp[i - 1][1]-prices[i]);
dp[i][1]=max(dp[i - 1][1], dp[i - 1][2]);
dp[i][2]=dp[i - 1][0] + prices[i];
}
// 4、返回值
return max(dp[n - 1][1], dp[n - 1][2]);
}
}; 16、714.买卖股票的最佳时期II（含手续费）
①状态表示：
f[i]表示：第i天结束后，处于“买入”状态，此时的最大利润。
g[i]表示：第i天结束后，处于“卖出”状态，此时的最大利润。
②状态转移方程：（状态机）
f[i]=max(f[i-1],g[i-1]-prices[i])
g[i]=max(g[i-1],f[i-1]+prices[i]-fee)
③初始化：f[0]=-prices[0] g[0]=0
④填表顺序：从左往右，两个表一起填。
⑤返回值：g[n-1]
class Solution
{
public:
int maxProfit(vector& prices, int fee)
{
// 1、创建dp表
int n = prices.size();
vector f(n), g(n);
// 2、初始化
f[0]=-prices[0];
// 3、填表
for(int i = 1; i < n; i++)
{
f[i] = max(f[i - 1], g[i - 1] - prices[i]);
g[i] = max(g[i - 1], f[i - 1] + prices[i] - fee);
}
// 4、返回值
return g[n - 1];
}
}; 17、714.买卖股票的最佳时期III
①状态表示：
f[i][j]表示：第i天结束后，完成了j次交易，此时处于“买入”状态，此时的最大利润。
g[i][j]表示：第i天结束后，完成了j次交易，处于“卖出”状态，此时的最大利润。
②状态转移方程：（状态机）
f[i][j]=max(f[i-1][j],g[i-1][j]-prices[i])
g[i]=g[i-1][j] if(j-1>=0) g[i][j]=max(g[i][j],f[i-1][j-1]+prices[i])
③初始化：f[0][0]=-prices[0] g[0][0]=0 f[0][1]=f[0][2]=g[0][1]=g[0][2]=-0x3f3f3f3f
④填表顺序：从上往下填写每一行，每一行从左往右，两个表一起填。
⑤返回值：g表的最后一行里面的最大值。
class Solution
{
public:
const int INF = 0x3f3f3f3f;
int maxProfit(vector& prices)
{
// 1、创建dp表
int n = prices.size();
vector> f(n, vector(3, -INF));
auto g = f;
// 2、初始化
f[0][0] = -prices[0], g[0][0] = 0;
// 3、填表
for(int i = 1; i < n; i++)
{
for(int j = 0; j < 3; j++)
{
f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);
g[i][j] = g[i - 1][j];
if(j - 1 >= 0) g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);
}
}
// 4、返回值
int ret = 0;
for(int j = 0; j < 3; j++)
ret = max(ret, g[n - 1][j]);
return ret;
}
}; 19、53.最大子数组和
①状态表示：dp[i]以i位置元素为结尾的所有子数组的最大和。
②状态转移方程：
长度为一：dp[i]=nums[i]
长度大于一：dp[i]=dp[i-1]+nums[i]
dp[i]=max(nums[i],dp[i-1]+nums[i])
③初始化：虚拟节点：dp[0]=0
④填表顺序：从左往右。
⑤返回值：整个dp表里的最大值
class Solution
{
public:
int maxSubArray(vector& nums)
{
// 0、处理边界条件
int n = nums.size();
if(n == 0) return 0;
// 1、创建dp表
vector dp(n + 1);
int ret = INT_MIN; 4、返回值
// 2、初始化
// 3、填表
for(int i = 1; i <= n; i++)
{
dp[i] = max(nums[i - 1], dp[i - 1] + nums[i-1]);
ret = max(ret, dp[i]);
}
return ret;
}
}; 20、53.最大子数组和
①状态表示：
f[i]表示：以i位置元素为结尾的所有子数组的最大和。
g[i]表示：以i位置元素为结尾的所有子数组的最小和。
②状态转移方程：
长度为一：f[i]=nums[i]
长度大于一：f[i]=dp[i-1]+nums[i]
f[i]=max(nums[i],f[i-1]+nums[i])
长度为一：g[i]=nums[i]
长度大于一：g[i]=g[i-1]+nums[i]
g[i]=min(nums[i],g[i-1]+nums[i])
③初始化：虚拟节点：dp[0]=0
④填表顺序：从左往右，两个表一起填。
⑤返回值：sum==gmin?fmax:max(fmax,sum-gmin)
class Solution
{
public:
int maxSubarraySumCircular(vector& nums)
{
// 1、创建dp表
int n = nums.size();
vector f(n + 1), g(n + 1);
int fmax = INT_MIN, gmin = INT_MAX, sum = 0;
// 2、初始化
// 3、填表
for(int i = 1; i <= n; i++)
{
int x = nums[i - 1];
f[i] = max(x, f[i - 1] + x);
fmax = max(fmax, f[i]);
g[i] = min(x, g[i - 1] + x);
gmin = min(gmin, g[i]);
sum += x;
}
// 4、返回值
return sum == gmin ? fmax : max(fmax, sum - gmin);
}
}; 21、152.乘积最大子数组
①状态表示：
f[i]表示：以i位置元素为结尾的所有子数组的最大积。
g[i]表示：以i位置元素为结尾的所有子数组的最小积。
②状态转移方程：
长度为一：f[i]=nums[i]
长度大于一：if(nums[i]>0) f[i]=f[i-1]*nums[i]
if(nums[i]<0) f[i]=g[i-1]*nums[i]
f[i]=max(nums[i],f[i-1]*nums[i],g[i-1]*nums[i])
长度为一：f[i]=nums[i]
长度大于一：if(nums[i]>0) g[i]=g[i-1]*nums[i]
if(nums[i]<0) g[i]=f[i-1]*nums[i]
g[i]=min(nums[i],g[i-1]*nums[i],f[i-1]*nums[i])
③初始化：虚拟节点：f[0]=g[0]=1
④填表顺序：从左往右，两个表一起填。
⑤返回值：f表中的最大值。
class Solution
{
public:
int maxProduct(vector& nums)
{
// 1、创建dp表
int n = nums.size();
vector f(n + 1), g(n + 1);
int ret = INT_MIN;
// 2、初始化
f[0] = g[0] = 1;
// 3、填表
for(int i = 1; i <= n; i++)
{
int x = nums[i - 1];
f[i] = max(x, max(f[i - 1] * x, g[i - 1] * x));
g[i] = min(x, min(g[i - 1] * x, f[i - 1] * x));
ret = max(ret, f[i]);
}
// 4、返回值
return ret;
}
}; 22、1567. 乘积为正数的最长子数组长度
①状态表示：
f[i]表示：以i位置元素为结尾的所有子数组中乘积为正数的最长长度 。
g[i]表示：以i位置元素为结尾的所有子数组中乘积为负数的最长长度 。
②状态转移方程：
长度为一： if(nums[i]>0) f[i]=1
if(nums[i]<0) f[i]=0
长度大于一：if(nums[i]>0) f[i]=f[i-1]+1
if(nums[i]<0) f[i]=g[i-1]==0?0:g[i-1]+1
故if(nums[i]>0) f[i]=f[i-1]+1
if(nums[i]<0) f[i]=g[i-1]==0?0:g[i-1]+1
长度为一： if(nums[i]>0) g[i]=0
if(nums[i]<0) g[i]=1
长度大于一：if(nums[i]>0) g[i]=g[i-1]==0?0:g[i-1]+1
if(nums[i]<0) g[i]=f[i-1]+1
故if(nums[i]>0) g[i]=g[i-1]==0?0:g[i-1]+1
if(nums[i]<0) g[i]=f[i-1]+1
③初始化：虚拟节点：f[0]=g[0]=0
④填表顺序：从左往右，两个表一起填。
⑤返回值：f表中的最大值。
class Solution
{
public:
int getMaxLen(vector& nums)
{
// 1、创建dp表
int n = nums.size();
vector f(n + 1), g(n + 1);
int ret = INT_MIN;
// 2、初始化
// 3、填表
for(int i = 1; i <= n; i++)
{
if(nums[i - 1] > 0)
{
f[i] = f[i - 1] + 1;
g[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
}
else if(nums[i - 1]<0)
{
f[i] = g[i - 1] == 0 ? 0 : g[i - 1] + 1;
g[i] = f[i - 1] + 1;
}
ret = max(ret, f[i]);
}
// 4、返回值
return ret;
}
}; 23、413.等差数列划分
①状态表示：
dp[i]表示：以i位置元素为结尾的所有子数组中有多少个等差数列。
②状态转移方程：
if(c-b==b-a) dp[i]=dp[i-1]+1
if(c-b!=b-a) dp[i]=0
dp[i]=c-b==b-a?dp[i-1]+1:0
③初始化：dp[0]=dp[1]=0
④填表顺序：从左往右。
⑤返回值：dp表内所有元素的和。
class Solution
{
public:
int numberOfArithmeticSlices(vector& nums)
{
// 1、创建dp表
int n = nums.size();
vector dp(n);
int ret = 0;
// 2、初始化
// 3、填表
for(int i = 2; i < n; i++)
{
dp[i] = nums[i] - nums[i-1] == nums[i - 1] - nums[i - 2] ? dp[i - 1] + 1 : 0;
ret += dp[i];
}
// 4、返回值
return ret;
}
}; 24、413.最长湍流子数组
①状态表示：
错误状态表示：以i位置元素为结尾的所有子数组中，最长湍流子数组的长度。
正确状态表示：
f[i]表示:以i位置元素为结尾的所有子数组中，最后呈现“上升”状态的最长湍流子数组的长度。
g[i]表示:以i位置元素为结尾的所有子数组中，最后呈现“下降”状态的最长湍流子数组的长度。
②状态转移方程：
if(a>=b) f[i]=1
if(a
if(a>b) g[i]=f[i-1]+1√
if(a<=b) g[i]=1
g[i]=a>b?g[i-1]+1:1
③初始化：f表和g表初始化为1
④填表顺序：从左往右，两个表一起填。
⑤返回值：f表与g表内最大值。
class Solution
{
public:
int maxTurbulenceSize(vector& nums)
{
// 1、创建dp表 // 2、初始化
int n = nums.size();
vector f(n, 1), g(n, 1);
int ret = 1;
// 3、填表
for(int i = 1; i < n; i++)
{
if(nums[i - 1] < nums[i]) f[i] = g[i - 1] + 1;
else if(nums[i - 1] > nums[i]) g[i] = f[i - 1] + 1;
ret = max(ret, max(f[i], g[i]));
}
// 4、返回值
return ret;
}
}; 25、139. 单词拆分
①状态表示：
dp[i]表示:[0,i]区间内的字符串，能否被字典中的单词拼接而成。
②状态转移方程：根据最后一个位置的情况，来划分问题。设j为最后一个单词起始位置的下标（0<=j<=i）。
if(dp[j-1]==true&&s[j~i]在字典中，dp[i]=true
else dp[i]=false
③初始化：虚拟节点确保后续填表正确dp[0]=true，下标的映射关系s='_'+s
④填表顺序：从左往右。
⑤返回值：dp[n]。
class Solution
{
public:
bool wordBreak(string s, vector& wordDict)
{
unordered_set hash;
for(auto& s : wordDict) hash.insert(s);
int n = s.size();
vector dp(n + 1);
dp[0] = true; // 保证后续填表是正确的
s = ' ' + s; // 使原始字符串的下标统一+1
for(int i = 1; i <= n; i++) // 填dp[i]
{
for(int j = i; j >= 1; j--) // 最后一个单词的起始位置
{
if(dp[j - 1] && hash.count(s.substr(j, i - j + 1)))
{
dp[i] = true;
break;
}
}
}
return dp[n];
}
}; 26、467. 环绕字符串中唯一的子字符串
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子串里面，有多少个在base中出现过。
②状态转移方程：
长度为一：dp[i]=1
长度大于一：if(s[i-1]+1==s[i]||s[i-1]=='z'&&s[i]=='a') dp[i]=dp[i-1]
dp[i]=1+dp[i-1]
③初始化：dp表里的值都初始化为1。
④填表顺序：从左往右。
⑤返回值：返回dp表中所有元素的和。
去重：相同字符结尾的dp值，取最大的即可
1、创建一个大小为26的数组。
2、里面的值保存相应字符结尾的最大的dp值即可。
3、返回数组里的和。
class Solution
{
public:
int findSubstringInWraproundString(string s)
{
int n = s.size();
vector dp(n, 1);
for(int i = 1; i < n; i++)
{
if(s[i - 1]+1 == s[i] || s[i - 1] == 'z' && s[i] == 'a')
dp[i] += dp[i - 1];
}
int hash[26] = { 0 };
for(int i = 0; i < n; i++)
hash[s[i] - 'a'] = max(hash[s[i] - 'a'], dp[i]);
int sum = 0;
for(auto& x : hash) sum += x;
return sum;
}
}; 27、300.最长递增子序列
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列里面，最长递增子序列的长度。
②状态转移方程：
长度为一：dp[i]=1
长度大于一：if（nums[j]
④填表顺序：从左往右。
⑤返回值：返回dp表中的最大值。
class Solution
{
public:
int lengthOfLIS(vector& nums)
{
int n = nums.size();
vector dp(n, 1);
int ret = 1;
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
if(nums[j] < nums[i])
dp[i] = max(dp[i], dp[j] + 1);
ret = max(ret, dp[i]);
}
return ret;
}
}; 28、376. 摆动序列
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列里面，最长摆动序列的长度。×
f[i]表示:以i位置的元素为结尾的所有子序列里面，最后一个位置呈现“上升”趋势的最长摆动序列的长度。
g[i]表示:以i位置的元素为结尾的所有子序列里面，最后一个位置呈现“下降”趋势的最长摆动序列的长度。
②状态转移方程：
（上升）长度为一：f[i]=1
长度大于一：if（nums[j]
长度大于一：if（nums[j]>nums[i]) g[i]=max(f[j]+1)
③初始化：dp表里的值都初始化为1。
④填表顺序：从左往右。
⑤返回值：f表和g表中的最大值。
class Solution
{
public:
int wiggleMaxLength(vector& nums)
{
int n = nums.size();
vector f(n, 1), g(n, 1);
int ret = 1;
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
{
if(nums[j] < nums[i]) f[i] = max(f[i], g[j] + 1);
else if(nums[j] > nums[i]) g[i] = max(g[i], f[j] + 1);
}
ret = max(ret, max(f[i], g[i]));
}
return ret;
}
}; 29、673. 最长递增子序列的个数
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列里面，最长递增子序列的个数。×
len[i]表示:以i位置的元素为结尾的所有子序列里面，最长递增子序列的长度。
count[i]表示:以i位置的元素为结尾的所有子序列里面，最长递增子序列的个数。
②状态转移方程：
if(len[j]+1==len[i]) count[i]+=count[j]
if(len[j]+1
③初始化：len[i]=count[i]=1(两个表都初始化为1）
④填表顺序：从左往右。
⑤返回值：通过小贪心的策略从左往右扫描时找最大值的同时，也更新最大值的个数。
class Solution
{
public:
int findNumberOfLIS(vector& nums)
{
int n = nums.size();
vector len(n, 1), count(n, 1);
int retlen = 1, retcount = 1;
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
{
if(nums[j] < nums[i])
{
if(len[j] + 1 == len[i]) count[i] += count[j];
else if(len[j] + 1 > len[i]) len[i] = len[j] + 1, count[i] = count[j];
}
}
if(retlen == len[i]) retcount += count[i];
else if(retlen < len[i]) retlen = len[i], retcount = count[i];
}
return retcount;
}
}; 30、673. 最长递增子序列的个数
①状态表示：（先预处理：按照第一个元素排序即可）
dp[i]表示:以i位置的元素为结尾的所有数对链中，最长数对链的长度。
②状态转移方程：
长度为1：dp[i]=1
长度大于1：if(p[j][1]
④填表顺序：从左往右。
⑤返回值：dp表中的最大值。
class Solution
{
public:
int findLongestChain(vector>& pairs)
{
sort(pairs.begin(), pairs.end());
int n = pairs.size();
vector dp(n, 1);
int ret = 1;
for(int i = 1; i < n; i++)
{
for(int j = 0; j < i; j++)
{
if(pairs[j][1] 31、1218. 最长定差子序列
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列里面，最长等差子序列的长度。
②状态转移方程：
b不存在：1
b存在：最后一个：dp[j]+1
优化：将元素+dp[j]的值，绑定放在哈希表中。直接在哈希表中，做动态规划。
③初始化：hash[arr[0]]=1
④填表顺序：从左往右。
⑤返回值：dp表中的最大值。
class Solution
{
public:
int longestSubsequence(vector& arr, int difference)
{
unordered_map hash;
hash[arr[0]] = 1;
int ret = 1;
for(int i = 1; i < arr.size(); i++)
{
hash[arr[i]] = hash[arr[i] - difference] + 1;
ret = max(ret, hash[arr[i]]);
}
return ret;
}
}; 32、1218. 最长定差子序列①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列中，最长斐波那契子序列的长度。×
dp[i][j]表示:以i位置以及j位置为结尾的所有子序列里面，最长斐波那契子序列的长度。
②状态转移方程：nums[i]=b;nums[j]=c;nums[k]=a;
a存在，且a
③初始化：表里面所有的值都初始化为2。
④填表顺序：从上往下。
⑤返回值：dp表中的最大值。ret<3?0:ret
class Solution
{
public:
int lenLongestFibSubseq(vector& arr)
{
int n = arr.size();
// 优化
unordered_map hash;
for(int i = 0; i < n; i++) hash[arr[i]] = i;
int ret = 2;
vector> dp(n, vector(n, 2));
for(int j = 2; j < n; j++) // 固定最后一个位置
{
for(int i = 1; i < j; i++)
{
int a = arr[j] - arr[i];
if(a < arr[i] && hash.count(a)) dp[i][j] = dp[hash[a]][i] + 1;
ret = max(ret, dp[i][j]);
}
}
return ret < 3 ? 0 : ret;
}
}; 33、1027. 最长等差数列
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列中，最长等差序列的长度。×
dp[i][j]表示:以i位置以及j位置为结尾的所有子序列里面，最长等差序列的长度。
②状态转移方程：nums[i]=b;nums[j]=c;nums[k]=a;
a存在，且a
法一：将数组中所有元素与它们的下标绑定<元素，下标数组>，存在哈希表中。直接在哈希表中，做动态规划。(可行但超时）
法二：一边dp，一边保存离它最近的下标。<元素，下标>
③初始化：dp表中所有的值都初始化为2。
④填表顺序:
法一：先固定最后一个数，再枚举倒数第二个数（无法保存下标）
法二：先固定倒数第二个数，再枚举最后一个数。
选第二种填表方式，当i位置填完之后，将i位置的值放入哈希表中即可。
⑤返回值：dp表中的最大值。
class Solution
{
public:
int longestArithSeqLength(vector& nums)
{
// 优化
unordered_map hash;
hash[nums[0]] = 0;
int n = nums.size();
vector> dp(n, vector(n, 2)); // 创建dp表 + 初始化
int ret = 2;
for(int i = 1; i < n; i++) // 固定倒数第二个数
{
for(int j = i + 1; j < n; j++) // 枚举倒数第一个数
{
int a = 2 * nums[i] - nums[j];
if(hash.count(a))
dp[i][j] = dp[hash[a]][i] + 1;
ret = max(ret, dp[i][j]);
}
hash[nums[i]] = i;
}
return ret;
}
}; 33、446.等差数列划分 II - 子序列
①状态表示：
dp[i]表示:以i位置的元素为结尾的所有子序列中，等差子序列的个数。（×只知道子序列的个数，但不能确定一个具体的子序列）
dp[i][j]表示:以i位置以及j位置为结尾的所有子序列中，等差子序列的个数。
②状态转移方程：nums[i]=b;nums[j]=c;nums[kx]=a;
a存在，且kx
优化：将<元素，下标数组>绑定在一起，存在哈希表中。
③初始化：dp表中所有的值都初始化为0。
④填表顺序:先固定最后一个数，再枚举倒数第二个数
⑤返回值：dp表中的所有元素的和。
class Solution
{
public:
int numberOfArithmeticSlices(vector& nums)
{
int n = nums.size();
// 优化
unordered_map> hash;
for(int i = 0; i < n; i++) hash[nums[i]].push_back(i);
vector> dp(n, vector(n)); // 创建dp表 + 初始化
int sum = 0;
for(int j = 2; j < n; j++) // 固定倒数第二个数
{
for(int i = 1; i < j; i++) // 枚举倒数第一个数
{
long long a = (long long)2 * nums[i] - nums[j];
if(hash.count(a))
{
for(auto k : hash[a])
{
if(k < i) dp[i][j] +=dp[k][i] + 1;
}
}
sum += dp[i][j];
}
}
return sum;
}
};