2021-04-04

动态规划

动态规划算法通常用于求解具有某种最优性质的问题。例如（最大小，最多少）
在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。

其中具有的固定名词：

阶段
把整个复杂的问题分解成一个个的阶段 ，要是每个阶段都有最优解，那么整个问题就会有最优解；此处的每个阶段的最优解和贪心算法不同 贪心算法是按照统一的不变的标准来求最优解；动态规划是按照余下的状态（阶段解）最优
来确定状态转移方程；从后往前推 一步步求解；

最优子结构

一个最优子结构具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的状态最优；例如 要求最大子序列；那么就假设以i个数结束 然后让前i-1数组成的子序列最大 那么再加上第i个数就是前i个数的最大子序列；

状态

意思是我们所要求的东西；每个阶段的开始或者结束时的值；

状态转移方程*
当进行到某个阶段的开始是 或者结束时 即一个阶段和下一个阶段的分界点时 所要做出的对状态的操作
注意 整个问题 状态转移方程一般只有一个

基本思想

1.先将问题分成几个阶段 （几种情况） 确定该状态我们想要的值
2. 通过状态转移方程来确定下一个状态（情况）的值 （通过循环来遍历所有的状态）
3. 这个时候需要一个能记录该状态值的容器 （一般是数组）下标是状态编号；内容是状态值； 把所有状态都遍历一遍后，把值存入数组后；
4. 遍历一遍数组 ，把我们要的最值输出 ；

例题

子序列问题

最大连续子序列
给定K个整数的序列{ N1, N2, …, NK }，其任意连续子序列可表示为{ Ni, Ni+1, …,
Nj }，其中 1 <= i <= j <= K。最大连续子序列是所有连续子序列中元素和最大的一个，
例如给定序列{ -2, 11, -4, 13, -5, -2 }，其最大连续子序列为{ 11, -4, 13 }，最大和
为20。

思路：设以第k个元素结束得到的最长子序列长度为dp[k];(将状态值存入数组)
状态变化方程为 dp【k】=max【dp【k-1】+a【k】】，0】
将每个状态的最优值遍历出来 然后最优中求最优；思路是从后往前推
还有一种思路``从前往后推；

。

for(int i=0;i<n;i++)
      cin>>a[i];
      int sum=a[0],ans=a[0];   //sum为状态数组  ans为答案
      for(int i=1;i<n;i++)//设以第k个数子链结束；从1开始
 
      {
             if(sum>=0)      如果a[i]>0,sum=a[1]
                            如果a[2]<0   所以以第2个元素结尾的子列最大就a[1]
                            那么对第三个元素结尾的最大子列就分两种情况
                            1 a[1]>a[2]   sum=a[1]+a[2]
                            2 a[1] <a[2]  sum=0 意思是从0开始从新记录 
               {   
                  sum+=a[i];  
                  
             }
             else
             {
                   sum=a[i];
                  
             }

            if(sum>ans){    //每一次都比较一次  把最大的值保留下来；
                  ans=sum；
           }

公共子序列

输入 abcfbc abfcab 输出 4
输入programming contest 输出 2

即比较两个字符串的元素相同个数 但是 是有顺序的比较
例如qwe wqe
输出是2 而不是3
qwe中a[1]=q,
wqe中z[1]=w z[2]=q
所以把q放入公共链c 中，
即c[1]=q;
但是a[2]=w ;z[1]=w 却不能把w放到c[2], 因为c[1]=q,c[2]=w；这与wqe的顺序不符；

for(int i=1;i<=a.length();i++)       //值得注意的地方  字符串是以下标0开始的
      for(int j=1;j<=b.length();j++)   //所以 第一重是元素个数；
      
      {                              //第二重是元素下标加1
      if(a[i-1]==b[j-1])
      dp[i][j]=dp[i-1][j-1]+1;     //dp[i][j]意思是a[i]结束 b【j】结束的两个链的公共链 
      else
            dp[i][j]=max(dp[i-1][j],dp[i][j-1]);

      }  //因为a[i]和b[j]越靠后  可能重叠的公共链就越长，所以输出最长； 
           cout<<dp[a.length()][b.length()]<<endl;  
      
     

dp【10000】【10000】的初始值都是0
状态转移方程

  if(a[i-1]==b[j-1])
  dp[i][j]=dp[i-1][j-1]+1;
  else
        dp[i][j]=max(dp[i-1][j],dp[i][j-1]);

意思是（1）如果am-1 == bn-1，则当前最长公共子序列为 "a0, a1, …, am-2"与"b0, b1, …, bn-2"的最长公共子序列与am-1（bn-1）所组成。
长度为"a0, a1, …, am-2"与"b0, b1, …, bn-2"的最长公共子序列的长度+1。

（2）如果am-1 != bn-1，则最长公共子序列为max（"a0, a1, …, am-2"与"b0, b1, …, bn-1"的公共子序列，"a0, a1, …, am-1"与"b0, b1, …, bn-2"的公共子序列）

说实话 感觉动态规划的题关键是找状态转移方程
就目前所阅读过的题来说 大体方向是从后往前推
并且注意所用词 子段 和子序列 是不同的
子段是连续的不间断的
子序列是有序的 可间断的可连续的