动态规划笔记

最新推荐文章于 2024-09-18 20:33:32 发布

铁头娃娃头铁

最新推荐文章于 2024-09-18 20:33:32 发布

阅读量123

点赞数

分类专栏： codeblock 文章标签：算法动态规划

本文链接：https://blog.csdn.net/weixin_44639048/article/details/104469836

版权

codeblock 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

动态规划专题

动态规划专题

动态规划的递归写法和递推写法

递归写法

Fibonacci(斐波那契数列)

int F(int n)
{
    if(n == 0 || n == 1)    return 1;
    else return F(n-1) + F(n-2);
}

缺点：重复计算，例如当n==5时,F(5) = F(4) + F(3)，而F(4) = F(3) + F(2),多计算了一次F(3)。
改进：用空间换时间，一维数组dp记录F(n)的结果，dp[i] = -1时表示未计算过

int dp[MAXN];

int F(int n)
{
    if(n == 0 || n == 1)    return 1;
    if(dp[n] != -1)     return dp[n];   //已经计算过结果返回
    else
    {
        dp[n] = F(n-1) + F(n-2);    
        return dp[n];                   //计算完结果返回
    }
}

时间复杂度：O(2ⁿ)->O(n)
空间复杂度：O(1)->O(n)

递推写法

数塔问题

状态转移方程

dp[i][j] = max(dp[i+1][j], dp[i+1][j+1]) + f[i][j]

状态：dp[i][j]
决策：走位置[i][j]的左下还是右下
边界：可以直接确定其结果的部分

边界dp出在最底层各位置，不断往上求出每一层的dp值，最后会得到dp[1][1]

总结

递推写法自顶向上
递归写法自顶向下

一个问题必须拥有重叠子问题和最优子结构，才能使用动态规划去解决

最大连续子列和

状态转移方程

d[i] = max(A[i], dp[i-1] + A[i])

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10010;
int A[MAXN], dp[MAXN];
int main()
{
    int n;
    cin>>n;
    for(int i = 0; i < n; ++i)
        cin>>A[i];
    dp[0] = A[0];
    for(int i = 1; i < n; ++i)
        dp[i] = max(A[i], dp[i - 1] + A[i]);
    //dp[i]中存放以A[i]结尾的连续序列的最大和
    int k = 0;
    for(int i = 1; i < n; ++i)
        if(dp[i] > dp[k])
            k = i;
    cout<<dp[k];
    return 0;
}

状态的无后效性：当前状态记录了历史信息，一旦当前状态确定，就不会再改变，历史信息只能通过已有的状态去影响未来的决策

动态规划核心

状态转移方程
边界状态

最长不下降子序列

状态转移方程

dp[i] = max(1, dp[j] + 1)
(j = 1,2,...,i-1 && A[j] < A[i])

for(int i = 1; i <= n; ++i)
{
    dp[i] = 1;  //边界初始条件，即每个元素自成一个序列
    for(int j = 1; j < i; ++j)
        if(A[i] > A[j] && dp[j] + 1 > dp[i])  //状态转移条件，即更新A[i]的条件
            dp[i] = dp[j] + 1;
    ans = max(ans, dp[i]);  //ans为最大的dp[i]
}
//1.A[i]>A[j]，能够插入到以A[j]为末尾的队伍中
//2.dp[j] + 1，以A[j]为末尾的队伍的长度+1，即并入A[i]

最长公共子序列(子序列可以不连续)

状态转移方程
$dp[i][j]=\left\{ \begin{aligned} & dp[i - 1][j - 1] + 1, A[i] == B[j] \\ & max(dp[i - 1][j], dp[i][j - 1]), A[i] != B[j] \\ \end{aligned} \right.$
边界
$d p [i] [j] = 0$

//字符串从下标为1读入   
//边界全部设置为0,即无公共子序列，从dp[1][1]开始
for(int i = 1; i <= lenA; ++i)
{
    for(int j = 1; j <= lenB; ++j)
    {
        if(A[i] == B[i])
            dp[i][j] = dp[i - 1][j - 1] + 1;
        else
            dp[i][j] = max(dp[i][j-1], dp[i-1][j]);
    }
}
cout<<dp[lenA][lenB];

最长回文子串

状态转移方程
$dp[i][j]=\left\{ \begin{aligned} & dp[i + 1][j - 1] , S[i] == S[j] \\ & 0, S[i] != S[j] \\ \end{aligned} \right.$
边界
$d p [i] [j] = 1, d p [i] [i + 1] = (S [i] = = S [i + 1]) ? 1 : 0$

//边界
for(int i = 0; i < len; ++i)
{
    dp[i][i] = 1;
    if(i < len - 1)
    {
        if(S[i] == S[i + 1])
        {
            dp[i][i+1] = 1;
            ans = 2;
        }
    }
}
//状态转移方程
for(int L = 3; L <= len; ++L)
{
    for(int i = 0; i + L - 1 < len; ++i)
    {
        int j = i + L -1;
        if(S[i] == S[j] && dp[i+1][j-1] == 1)
        {
            dp[i][j] = 1;
            ans = L;
        }
    }
}