算法篇:动态规划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 f[i]=a>=b?1:g[i-1]+1
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表里的值都初始化为1。
④填表顺序:从左往右。
⑤返回值:返回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] (下降)长度为一:g[i]=1
长度大于一: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 if(len[j]+1>len[i]) len[i]=len[j]+1; count[i]=count[j]
③初始化: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] ③初始化:表中元素都初始化为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 a存在,且b 优化:将数组中所有元素与它们的下标绑定,存在哈希表中。直接在哈希表中,做动态规划。
③初始化:表里面所有的值都初始化为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 a存在,且b 优化:
法一:将数组中所有元素与它们的下标绑定<元素,下标数组>,存在哈希表中。直接在哈希表中,做动态规划。(可行但超时)
法二:一边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[i][j]+=dp[kx][i]+1
优化:将<元素,下标数组>绑定在一起,存在哈希表中。
③初始化: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;
    }
};

你可能感兴趣的:(算法,动态规划)