Day_27，动态规划（详细描述及最长公共子序列问题解决）

上一篇动态规划最直观的感受就是，存在着大量重复的子问题，我们利用查表的方式去解决并以此减少运行时间。
这篇文章主要解决以下几个问题：
1、动态规划的原理是什么？要在什么时候使用动态规划？
2、最优子结构的产生方式？
3、最长公共子序列问题

动态规划的原理是什么？要在什么时候使用动态规划？

动态规划： 动态规划是用来解决 子问题重叠 的情况，对于这部分重叠的问题，可以预先创建一份表，对应保存着这些子问题的解，在遇到重叠的子问题的时候就直接读表求解而不用重新计算，以此减少运行时间。他与分治法十分相似，但是分治法是将问题划分为 互不相交的子问题 ，递归求解子问题，在将解组合起来。
动态规划何时使用：
需要具备两个要素 “最优子结构”和“子问题重叠” ，下面仔细的说一下这两个要素
最优子结构：
一个问题的解包含其子问题的最优解，则该问题具有最优子结构性质，需要注意的是在判断最优子结构的时候要注意子问题是无关的，即同一个原问题的一个子问题不影响另一个子问题的解。
子问题重叠：
构造的递归算法反复求解相同的问题，则该问题具有子问题重叠性质

如何找到最优子结构？

先找递归表达式, 再看表达式是不是最优子结构，就是能不能找出一个表示当前状态的方法， 使得对于每个当前状态都有唯一的答案。┓( ´∀` )┏ 这好难哦，以后学到了再来补充

最长公共子序列问题

什么是最长公共子序列：
子序列： 存在一个序列 X={x₁,x₂,x₃…x_n}，以及另一个序列 Z={z₁,z₂,z₃…z_m}，若序列Z与X序列中的某个序列 {x_a1,x_a2,x_a3…x_an}完全相等，并且a1~an是严格递增的，则称Z是X的子序列
公共子序列： Z 同时是X和Y的子序列。
最长公共子序列例子： X = {A,C,B,A,C,D} Y={A,B,C,A,D} 最长公共子序列为 Z={A,B,C,D}

动态规划求解问题：
我们还是按照下面步骤求解

1、如下图，其中X_k表示 {x₁,x₂,x₃,…x_k}

2、递归函数如下，其中c[i,j]表示X_i和Y_j的最长子序列。

3、4、在下面代码中展示

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <vector>
using namespace std;

//采用自底向上的方式，c用来存储已经计算出来的结果
vector<vector<string>> LCSCal(string *X,string *Y,int len1,int len2)
{
    vector<vector<string>> b(len1+1,vector<string>(len2+1));
    vector<vector<int>> c(len1+1,vector<int>(len2+1));
    for (int i=0;i<len1+1; i++)
        c[i][0]=0;
    for (int i=0;i<len1+1; i++)
        c[0][i]=0;
    for (int i=1;i<len1+1;i++)
        for (int j=1;j<len2+1;j++)
        {
            if (X[i-1]==Y[j-1])
            {
                c[i][j]=c[i-1][j-1]+1;
                b[i][j]="↖";
            }else if (c[i-1][j]>=c[i][j-1])
            {
                c[i][j]=c[i-1][j];
                b[i][j]="↑";
            }else
            {
                c[i][j]=c[i][j-1];
                b[i][j]="←";
            }
        }
    return b;
}

//构造最优解
int PrintAndGetMaxLenth(vector<vector<string>> a,string *X,int len1,int len2)
{
    int len = 0;
    string result[len1] = {} ;
    for (int i=len1;i>=1;)
        for (int j=len2;j>=1;)
        {
            if (a[i][j]=="↖")
            {
                result[len] = X[i-1];
                i--;
                j--;
                len++;
            }else if (a[i][j]=="↑")
            {
                i--;
            }else
            {
                j--;
            }
            if (i==0 || j==0)
            {
                for (int k =len;k>=0;k--)
                    cout<<result[k];
                return len;
            }
        }
}


int main()
{
    string a[] = {"A","B","C","B","D","A","B"};
    string b[] = {"B","D","C","A","B","A"};
    int len1 = sizeof(a) / sizeof(*a);
    int len2 = sizeof(b) / sizeof(*b);
    vector<vector<string>> result = LCSCal(a,b,len1,len2);
    for (int i=1;i<len1+1;i++)
    {
        for (int j=1;j<len2+1;j++)
            cout<<result[i][j];
        cout<<endl;
    }
    cout<<PrintAndGetMaxLenth(result,a,len1,len2);
}

上述算法中，c就是我们用来查找的表，并且采用自底向上的方法进行动态规划计算

题外话

算法真的好贪心哦，好喜欢红红火火恍恍惚惚！！！