动态规划算法

已于 2023-07-14 22:27:11 修改
阅读量403 收藏 2
点赞数
分类专栏： 杂文 文章标签： 动态规划 算法 矩阵
于 2023-04-06 17:33:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/GG_Bruse/article/details/129936768
版权

目录

一、概念

二、Fibonacci

三、字符串分割

四、三角矩阵

五、路径总数

六、最小路径和

七、背包问题

八、回文串分割

九、编辑距离

十、不同子序列

一、概念

DP定义

动态规划是分治思想的延伸，通俗一点来说就是大事化小，小事化无
在将大问题化解为小问题的分治过程中，保存对这些小问题已经处理好的结果，并供后面处理更大规模的问题时直接使用这些结果

动态规划具备了以下三个特点

  1. 把原来的问题分解成了几个相似的子问题
  2. 所有的子问题都只需要解决一次
  3. 储存子问题的解

动态规划问题一般从以下四个角度考虑

  1. 状态定义
  2. 状态间的转移方程定义
  3. 状态的初始化
  4. 返回结果

动态规划的本质：对问题状态的定义和状态转移方程的定义(状态以及状态之间的递推关系)

状态定义的要求：定义的状态一定要形成递推关系

适用场景：最大值/最小值, 可不可行, 是不是，方案个数

二、Fibonacci

难度：Easy

状态：F(n)

状态转移方程：F(n) = F(n - 1) + F(n - 2)

初始值：F(1) = F(2) = 1

返回值：F(n)

#include <vector>
class Solution {
public:
    int Fibonacci(int n) 
    {
        std::vector<int> v(40);
        v[1] = v[2] = 1;
        for(int i = 3;i <= n; ++i) {
            v[i] = v[i - 1] + v[i - 2];
        }
        return v[n];
    }
};

上述解法的空间复杂度为O(n)
其实F(n)只与相邻的前两项有关，没有必要保存所有子问题的解，只保存两个子问题的解即可
下面方法的空间复杂度将为O(1)

class Solution {
public:
    int Fibonacci(int n) {
        if(n == 1 || n == 2) return 1;
        int Fib1 = 1,Fib2 = 1;
        int ret = 0;
        for(int i = 3;i <= n; ++i) {
            ret = Fib1 + Fib2;
            Fib1 = Fib2;
            Fib2 = ret;
        }
        return ret;
    }
};

三、字符串分割

难度：Medium

状态:

子状态：前1，2，3，...,n个字符能否根据词典中的词被成功分词
F(i)：前i个字符能否根据词典中的词被成功分词

状态递推:

F(i)：true{j < i && F(j) && substr[j+1,i]能在词典中找到} OR false
在j小于i中，只要能找到一个F(j)为true，并且从j+1到i之间的字符能在词典中找到，则F(i)为true

初始值：F(0) = true

返回值：F(n)

#include <vector>
#include <string>
#include <unordered_set>
using namespace std;
class Solution {
public:
    bool wordBreak(string s, unordered_set<string>& dict) {
        if (s.empty()) return false;
        if (dict.empty()) return false;

        vector<bool> can_break(s.size() + 1, false);
        can_break[0] = true;//初始状态(辅助状态)
        for (int i = 1; i <= s.size(); ++i)
        {
            //j < i && F(j) && [j + 1, i]
            for (int j = 0; j < i; ++j)
            {
                if (can_break[j] && dict.find(s.substr(j, i - j)) != dict.end())
                {
                    can_break[i] = true;
                    break;
                }
            }
        }
        return can_break[s.size()];
    }
};

四、三角矩阵

难度：Medium

方法一：正向推导 

状态：

子状态：从(0,0)到(1,0),(1,1),(2,0),...(n,n)的最短路径和
F(i,j)：从(0,0)到(i,j)的最短路径和

状态转移方程：F(i,j) = min( F(i-1, j-1), F(i-1, j)) + triangle[i][j]

初始值：F(0,0) = triangle[0][0]

返回结果：min(F(n-1, i))

#include <vector>
using namespace std;
class Solution {
public:
    int minimumTotal(vector<vector<int> >& triangle) {
        if (triangle.empty()) return 0;
        int row = triangle.size();

        for (int i = 1; i < row; ++i) {
            for (int j = 0; j <= i; ++j) {
                if (j == 0) triangle[i][j] = triangle[i - 1][j] + triangle[i][j];//左边界
                else if (j == i) triangle[i][j] = triangle[i - 1][j - 1] + triangle[i][j];//右边界
                else triangle[i][j] = min(triangle[i - 1][j], triangle[i - 1][j - 1]) + triangle[i][j];
            }
        }
        int min_sum = triangle[row - 1][0];
        for (int j = 1; j < row; ++j) {
            min_sum = min(min_sum, triangle[row - 1][j]);
        }
        return min_sum;
    }
};

方法二：反向推导

状态：
子状态：从(n,n),(n,n-1),...(1,0),(1,1),(0,0)到最后一行的最短路径和
F(i,j)：从(i,j)到最后一行的最短路径和

状态转移方程：
F(i,j) = min( F(i+1, j), F(i+1, j+1)) + triangle[i][j]

初始值：
F(n-1,0) = triangle[n-1][0]    F(n-1,1) = triangle[n-1][1]，...， F(n-1,n-1) = triangle[n-1][n-1]

返回结果：
F(0, 0)

这种逆向思维不需要考虑边界，也不需要最后寻找最小值，直接返回F(0,0)即可

#include <vector>
using namespace std;
class Solution {
public:
    int minimumTotal(vector<vector<int> >& triangle) {
        int row = triangle.size();
        for (int i = row - 2; i >= 0; --i) {
            for (int j = 0; j <= i; ++j) {
                triangle[i][j] = min(triangle[i + 1][j], triangle[i + 1][j + 1]) + triangle[i][j];
            }
        }
        return triangle[0][0];
    }
};

五、路径总数

难度：Easy

状态：

子状态：从(0,0)到达(1,0),(1,1),(2,1),...(m-1,n-1)的路径数
F(i,j)：从(0,0)到达F(i,j)的路径数

状态递推：
F(i,j) = F(i-1,j) + F(i,j-1)

初始化：
特殊情况：第0行和第0列    F(0,i) = 1    F(i,0) = 1

返回结果：
F(m-1,n-1)

#include <vector>
using namespace std;
class Solution {
public:
    int uniquePaths(int m, int n) {
        if (m < 1 || n < 1) return 0;

        vector<vector<int>> v(m, vector<int>(n, 1));
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                v[i][j] = v[i - 1][j] + v[i][j - 1];
            }
        }
        return v[m - 1][n - 1];
    }
};

六、最小路径和

难度：Medium

状态：

子状态：从(0,0)到达(1,0),(1,1),(2,1),...(m-1,n-1)的最短路径
F(i,j)：从(0,0)到达F(i,j)的最短路径

状态转移方程：

F(i,j) = min{ F(i-1,j) , F(i,j-1) } + (i,j) 

初始值： 

F(0,0) = (0,0)        F(0,i) = F(0,i-1) + (0,i)        F(i,0) = F(i-1,0) + (i,0) （i > 0）

返回结果：F(m - 1,n - 1)

class Solution {
public:
    int minPathSum(vector<vector<int> >& grid) {
        if(grid.empty()) return 0;
        const int row = grid.size();
        const int col = grid[0].size();
        for(int i = 1;i < col; ++i) grid[0][i] += grid[0][i - 1];
        for(int i = 1;i < row; ++i) grid[i][0] += grid[i - 1][0];
        for(int i = 1; i < row; ++i) {
            for(int j = 1; j < col; ++j) {
                grid[i][j] += min(grid[i - 1][j], grid[i][j - 1]);
            }
        }
        return grid[row - 1][col - 1];
    }
};

七、背包问题

难度：Medium

状态：F(i, j)：前i个物品放入大小为j的背包中所获得的最大价值

状态递推：

对于第i个商品，若装不下：此时的价值与前 i-1 个的价值是一样的 F(i,j) = F(i-1,j)
若可以装入：需要在装或不装中选择最大的
F(i, j) = max{ F(i-1,j), F(i-1, j - A[i]) + V[i] }
F(i-1,j): 表示不把第i个物品放入背包中， 所以价值就是前i-1个物品放入大小为j的背包的最大价值
F(i-1, j - A[i]) + V[i]：表示第i个物品放入背包中，价值增加V[i]，但需腾出A[i]的大小放第i个商品

初始化：第0行和第0列都为0，表示没有装物品时的价值都为0 F(0,j) = F(i,0) = 0

返回值：F(n,m)

class Solution {
public:
    int backPackII(int m, vector<int>& a, vector<int>& v) {
        if (a.empty() || v.empty() || m <= 0) return 0;

        const int row = a.size() + 1;
        const int col = m + 1;

        vector<vector<int>> ret(row);
        for (int i = 0; i < row; ++i) {
            ret[i].resize(col, 0);
        }

        for (int i = 1; i < row; ++i) {
            for (int j = 1; j < col; ++j) {
                if (a[i - 1] > j) ret[i][j] = ret[i - 1][j];
                else ret[i][j] = max(ret[i - 1][j], ret[i - 1][j - a[i - 1]] + v[i - 1]);
            }
        }
        return ret[row - 1][col - 1];
    }
};

优化版

每一行的结果都从上一行的结果推出，那么就可以优化空间复杂度为O(m)，从后向前推导即可

class Solution {
public:
    int backPackII(int m, vector<int>& a, vector<int>& v) {
        if (a.empty() || v.empty() || m <= 0) return 0;

        vector<int> ret(m + 1);
        for (int i = 1; i < a.size() + 1; ++i) {
            for (int j = m; j >= 1; --j) {
                if (a[i - 1] <= j) ret[j] = max(ret[j], ret[j - a[i - 1]] + v[i - 1]);
            }
        }
        return ret[m];
    }
};

八、回文串分割

难度：Hard

状态：
子状态：从第0个到第1，2，3，...，n个字符组成的字符串分割成回文 需要的最小分割数
F(i): 从第0个到第i个字符组成的字符串分割成回文 需要的最小分割数

状态递推：

若从j+1到i为回文字符串，且已经知道从第1个字符到第j个字符的最小切割数，那么只需要再切一次，就可以保证 1->j ， j+1 -> i都为回文串

(j < i) && (j+1 -> i)为true的情况下，F(i) = min( F[i], F[j] + 1)

初始化：F(i) = i - 1
单个字符只需要切0次，因为单子符都为回文串，2个字符最大需要1次，3个2次......

返回值：F(n)

class Solution {
public:
    bool isPal(string& s, int begin, int end)
    {
        while (begin < end) {
            if (s[begin] != s[end]) return false;
            ++begin;
            --end;
        }
        return true;
    }
    int minCut(string s) {
        int size = s.size();
        if (size == 0 || isPal(s, 0, size - 1)) return 0;

        vector<int> ret(size + 1);
        for (int i = 1; i <= size; ++i) {
            ret[i] = i - 1;
        }

        for (int i = 2; i <= size; ++i)
        {
            if (isPal(s, 0, i - 1)) {
                ret[i] = 0;
                continue;
            }
            for (int j = 1; j < i; ++j) {
                if (isPal(s, j, i - 1)) ret[i] = min(ret[i], ret[j] + 1);
            }
        }
        return ret[size];
    }
};

上述方法两次循环时间复杂度是O(n^2)，判断回文串时间复杂度是O(n)，所以总时间复杂度为O(n^3)。对于过长的字符串，在OJ的时候会出现TLE(Time Limit Exceeded)

判断回文串的方法可以使用动态规划进行优化，使总体时间复杂度为O(n^2)

状态： 

子状态：从第一个字符到第二个字符是不是回文串，第1-3，第2-5，...
F(i,j)：字符区间 [i,j] 是否为回文串

状态递推：

F(i,j)：true->{ s[i]==s[j] && F(i+1,j-1) } OR false
若字符区间首尾字符相同且在去掉区间首尾字符后字符区间仍为回文串，则原字符区间为回文串
从递推公式中可以看到第i处需要用到第i+1处的信息，所以i应该从字符串末尾遍历

初始化：F(i,j) = false

返回结果：矩阵F(n,n), 只更新一半值（i <= j），n^2 / 2

vector<vector<bool>> GetMat(string& s) {
    int size = s.size();
    vector<vector<bool>> ret(size, vector<bool>(size, false));
    for (int i = size - 1; i >= 0; --i) {
        for (int j = i; j < size; ++j) {
            if (i == j) ret[i][j] = true;
            else if (j == i + 1) ret[i][j] = (s[i] == s[j]) 
            else ret[i][j] = ((s[i] == s[j]) && ret[i + 1][j - 1]);
        }
    }
    return ret;
}

九、编辑距离

难度：Hard

状态：
子状态：word1的前1，2，3，...m个字符转换成word2的前1，2，3，...n个字符需要的编辑距离
F(i,j)：word1的前i个字符于word2的前j个字符的编辑距离

状态递推：

F(i,j) = min { F(i-1,j）+ 1，F(i,j-1) + 1，F(i-1,j-1) + (w1[i] == w2[j] ? 0 : 1) }
上式表示从删除，增加和替换操作中选择一个最小操作数

F(i-1,j)：w1[1,...,i-1]于w2[1,...,j]的编辑距离，删除w1[i]的字符--->F(i,j)

F(i,j-1)：w1[1,...,i]于w2[1,...,j-1]的编辑距离，增加一个字符--->F(i,j)

F(i-1,j-1)：w1[1,...,i-1]于w2[1,...,j-1]的编辑距离，若w1[i]与w2[j]相同，不做任何操作，编辑距离不变，若w1[i]与w2[j]不同，替换w1[i]的字符为w2[j]--->F(i,j)

初始值：初始化一定要是确定的值，如果这里不加入空串，初始值无法确定
F(i,0) = i：word与空串的编辑距离，删除操作
F(0,i) = i：空串与word的编辑距离，增加操作

返回值：返回结果：F(m,n)

class Solution {
  public:
    int minDistance(string word1, string word2) {
        int row = word1.size();
        int col = word2.size();
        vector<vector<int>> ret(row + 1, vector<int>(col + 1));
        for (int i = 0; i <= col; ++i) ret[0][i] = i;
        for (int i = 0; i <= row; ++i) ret[i][0] = i;

        for (int i = 1; i <= row; ++i) 
        {
            for (int j = 1; j <= col; ++j) 
            {
                if (word1[i - 1] == word2[j - 1]) {
                    ret[i][j] = min(ret[i - 1][j], ret[i][j - 1]) + 1;
                    ret[i][j] = min(ret[i][j], ret[i - 1][j - 1]);
                } else {
                    ret[i][j] = min(ret[i - 1][j], ret[i][j - 1]) + 1;
                    ret[i][j] = min(ret[i][j], ret[i - 1][j - 1] + 1);
                }
            }
        }
        return ret[row][col];
    }
};

十、不同子序列

难度：Hard 

状态：
子状态：S的前1,2,...,m个字符组成的字符串的子串 与T前1,2,...,n个字符组成的字符串相同的个数
F(i,j)：S[1:i]中的子串与T[1:j]相同的个数

状态递推：
当S[i] = T[j]时：
若使用S[i]匹配T[j]，则F(i,j) = F(i-1,j-1)
若不使用S[i]匹配T[j]，则问题就变为S[1:i-1]中的子串与T[1:j]相同的个数，则F(i,j) = F(i-1,j)
故，S[i] == T[j]时，F(i,j) = F(i-1,j-1) + F(i-1,j)

当S[i] != T[j]：问题退化为S[1:i-1]中的子串与T[1:j]相同的个数。S[i] != T[j]时，F(i,j) = F(i-1,j)

初始化：引入空串进行初始化
F(i,0) = 1        S的子串与空串相同的个数，只有空串与空串相同

返回值：F(m,n)

class Solution {
public:
    int numDistinct(string S, string T) 
    {
        int row = S.size();
        int col = T.size();
        if(row < col) return 0;
        if(T.empty()) return 1;

        vector<vector<int>> ret(row + 1, vector<int>(col + 1, 0));
        ret[0][0] = 1;
        for(int i = 1; i <= row; ++i) 
        {
            ret[i][0] = 1;
            for(int j = 1;j <= col; ++j) 
            {
                if(S[i - 1] == T[j - 1])
                    ret[i][j] = ret[i - 1][j] + ret[i - 1][j - 1];
                else
                    ret[i][j] = ret[i - 1][j];
            }
        }
        return ret[row][col];
    }
};

GG_Bond20
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python+动态规划算法
05-13
python+动态规划算法
常用算法大全－动态规划算法
不再犹豫
05-27 3193
常用算法大全－动态规划算法 作者:       类别: 程序员 function doZoom(size){var zoom=document.all?document.all[Zoom]:document.getElementById(Zoom);zoom.style.fontSize=size+px;}字体大小: 小
算法-动态规划 Dynamic Programming--从菜鸟到老鸟
热门推荐
有图有真相
07-15 45万+
前言最近在牛客网上做了几套公司的真题，发现有关动态规划（Dynamic Programming）算法的题目很多。相对于我来说，算法里面遇到的问题里面感觉最难的也就是动态规划（Dynamic Programming）算法了，于是花了好长时间，查找了相关的文献和资料准备彻底的理解动态规划（Dynamic Programming）算法。一是帮助自己总结知识点，二是也能够帮助他人更好的理解这个算法。后面的参
动态规划学习动态规划算法
04-11
学习动态规划算法
动态规划算法笔记总结ZIP分享
12-01
进行动态规划问题的详细总结,总结了相关的经典问题,例如0-1背包问题,完全背包问题,然后对LeetCode若干使用动态规划实现的题型进行梳理和思路分析讲解
matlab实现动态规划算法 程序源码.zip
02-18
【达摩老生出品，必属...资源名：matlab实现动态规划算法 程序源码.zip 资源类型：程序源代码 源码说明： 基于matlab实现动态规划的程序，包含完整源码和注释，非常适合借鉴学习 适合人群：新手及有一定经验的开发人员
【算法】动态规划法
MING.MING的博客
03-11 2083
动态规划法定义及性质设计步骤核心动态规划算法的两种形式斐波那契数列两种解决方法 定义及性质 1、定义：把原问题分解为相对简单的子问题的方式求解复杂问题的方法 2、性质：重叠子问题和最优子结构性质 设计步骤 1.描述最优解的结构，可以利用子问题的最优解来构造原问题的最优解； 2.递归定义最优解的值 3.按自底向上的方式计算最优解的值 4.由计算出的结果构造一个最优解 核心 记住求解过的值，不用重新...
动态规划算法路径规划
最新发布
08-24
动态规划算法可以用于路径规划问题。路径规划是指在图或网络中找到从起点到终点的最优路径。动态规划算法通过将问题划分为子问题，并保存子问题的最优解，逐步构建出整个问题的最优解。 对于路径规划问题，可以使用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

GG_Bond20

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值