动态规划简析

动态规划

有什么用

用来解决最优化问题
应用于子问题重叠的问题，即不同的子问题具有公共的子子问题（子问题的求解是递归进行的，将其划分为更小的子问题）

优点

对每个子子问题只求解一次，将其解保存在一个表格中，从而无需每次求解一个子子问题时都要重新计算，避免了不必要的计算工作

怎么用

1. 将一个问题分解成多个类似的子问题，求解子问题，可用递归求解；
2. 用一个关联容器来记录所有子问题的最优解，每次循环或者递归前先检查是否已经解过这个子问题，如果解过了，那么就直接使用这个解，避免了重复计算
3. 一个例子：

#include <iostream>
#include <vector>
#include <unordered_map>
using namespace std;

#if 0
/** \brief	自顶向下
 * \param rod vector<int>&              不同长度的收益
 * \param len int                       要计算收益的长度
 * \param ern unordered_map<int,int>&   存储不同长度的最大收益
 * \return int                          最大收益
 */
int cutRod(vector<int> &rod, int len, unordered_map<int, int> &ern)
{
    //int len = r-l+1;
    if(len == 0) return 0;
    if(ern.find(len) != ern.end())
        return ern[len];
    int max_ern = -1;   //默认所有收益不小于零
    for(int i = 0; i <len; ++i)
    {
        max_ern = max(max_ern,rod[i] + cutRod(rod,len-i-1,ern));
    }
    ern[len] = max_ern;
    return max_ern;
}

#else
/** \brief	自底向上（更常用）
 * \param rod vector<int>&              不同长度的收益
 * \param len int                       要计算收益的长度
 * \param ern unordered_map<int,int>&   存储不同长度的最大收益
 * \return int                          最大收益
 */
int cutRod(vector<int> &rod, int len, unordered_map<int, int> &ern)
{
    if(len == 0) return 0;
    int max_ern = -1;   //默认所有收益不小于零，将其初始化为INT_MIN可能更合理，要添加<limits>
    for(int i = 1; i <= len; ++i)	//i和j代表最小长度
    {
        for(int j = 1; j <= i; ++j)
        {
            max_ern = max(max_ern,rod[j-1]+ern[i-j]);	//关联容器中ern[0]会自动添加并赋值0
        }
        ern[i] = max_ern;
    }
    //ern.erase(0);
    return max_ern;
}

#endif
void DebugPrint(unordered_map<int, int> &iern)
{
    for(auto i : iern)
    {
        cout << i.first << " " << i.second << endl;
    }
}
int cutRod(vector<int> &rod)	//返回最大收益
{
    unordered_map<int, int> iern;	//保存不同长度的最大收益
    int ans = -1;	//这里认为收益不会为负
    ans = cutRod(rod, rod.size(), iern);
    DebugPrint(iern);
    return ans;
}
int main()
{
    vector<int> rod = {1,5,8,9};
    cout << cutRod(rod) << endl;
    return 0;
}

什么时候用

使用动态规划求解的问题应具备的两个要素：
最优子结构和子问题重叠。

最长公共子序列(LCS)问题

序列X:[X1,X2,X3… …Xm]
序列Y:[Y1,Y2,Y3… …Yn]
X和Y的LCS: Z[Z1,Z2,Z3…Zk]
当Xm = Yn时，只有一种情况，此时由LCS的定义可知：Zk = Xm = Yn, 那么一个前缀序列Z(k-1)就是X(m-1)和Y(n-1)的一个长度为k-1的LCS。
当Xm !=Yn时，有两种情况，Zk !=Xm，那么也就说明前缀序列Z(k)是序列X(m-1)和序列Y(n)的LCS；另一种情况就是Zk != Yn，此时Z(k)是序列X(m)和序列Y(n-1)的LCS。
构造LCS：

1. 判断Xm是否与Yn相等，如果相等，那么在Z(k)中的Zk就能确定，继续分析子问题Xm-1与Yn-1是否相等。
2. 若Xm与Yn不相等，那么分别分析Xm-1与Yn的LCS；以及Xm与Yn-1的LCS。
3. 重复1和2两个步骤，最终将会找到LCS的所有元素。

#include <iostream>
#include <vector>
#include <string>

using namespace std;

int LCS_Len(const string &X, const string &Y, const int xLen, const int yLen)
{

    int i = 0;
    int j = 0;
    int c[xLen+1][yLen+1];    //Z长度：c[X长度+1][Y长度+1]
    //避免内存泄漏
    const int m = xLen;
    const int n = yLen;
    int flag[m][n];	//标志位

    for(i = 0; i <= xLen; ++i)  //Y长度为0时，无论X的长度为多少，Z的长度都应为0
        c[i][0] = 0;
    for(j = 0; j <= yLen; ++j)
        c[0][j] = 0;

    for(i = 1; i <= xLen; ++i)
    {
        for(j = 1; j <= yLen; ++j)
        {
            if(X[i-1] == Y[j-1])    //比较X、Y序列的第一个元素，Z序列的元素仅取决与X与Y相等的元素
            {
                c[i][j] = c[i-1][j-1] + 1;
                flag[i-1][j-1] = 0;
            }else
            {
                if(c[i-1][j] >= c[i][j-1])
                {
                    c[i][j] = c[i-1][j];
                    flag[i-1][j-1] = 1;
                }
                else
                {
                    c[i][j] = c[i][j-1];
                    flag[i-1][j-1] = -1;
                }
            }
        }
    }
    return c[xLen][yLen];	//flag是标志数组，值为0的元素，对应的行号就是数组X的字符下标
}

int LCS_Len(const string &X, const string &Y)
{
    const int m = X.size();
    const int n = Y.size();
    return LCS_Len(X,Y,m,n);
}

int main()
{
    string s1 = "ABCBDAB";
    string s2 = "BDCABA";
    const int m = s1.size();
    const int n = s2.size();
    cout << LCS_Len(s1, s2) << endl;	//输出的是LCS的长度。
    return 0;
}

时间效率为(m*n)