动态规划

2.阅读代码——动态规划

乔治·桑塔亚纳说过，“那些遗忘过去的人注定要重蹈覆辙。”这句话放在问题求解过程中也同样适用。不懂动态规划的人会在解决过的问题上再次浪费时间，懂的人则会事半功倍。那么什么是动态规划？这种算法有何神奇之处？

目的：为了避免解决重复性问题

斐波那契

1.递归算法

void fun(int n)
{
    if(n==0)
       return 0;
    if(n==1)
       return 1;
     reurn fun(n-2)+fun(n-1);
}

---

任何一个递归函数，都可以化成一棵树。

如图所示：

从图片上可以看到，以粉色为底的第二层f（3）同样在第三层也重复算了一遍，第三层的f（2）重复算了两遍，第四层也有f（2），这样的问题，我们叫做重复子问题，由于重复计算同一个值的斐波那契值，致使递归的效率不高，所以我们引进动态规划。

2.动态规划（简称DP）

动态规划的核心思想：

把原问题分解成若干个子问题进行求解，先求解子问题，然后从这些子问题得到原问题的姐解，不同的是，动态规划保存已解决的子问题的答案，便于在后面需要时能够马上得到，就可以节省大量的重复计算。

---

在动态规划里，有一个特别重要的角色，就是数组。而数组有一维数组和二维数组，至于是一维数组的选定还是二维数组的选定，要根据具体问题具体分析，一般二维数组解决较难的题目，讲到这里，其实还没有对动态规划形成一个具体的概念，请看下面的典型应用，加深理解。

3.动态规划的典型应用

一维应用：

斐波那契数列：

int fun(int x)
{
   int dp[max];
   dp[0]=0;dp[1]=1;dp[2]=1;
   
   for(int i=3;i<=x;i++)
   {
       dp[i]=dp[i-1]+dp[i-2];
   }
   return dp[x];
}

从上面就可以发现，如果当数据量急剧增大时，递归和动态规划的的效率也会有明显差异。

---

这里有一个小技巧，运用dp时，我们想要的得到的结果一般是数组的最后一个，例如我们求斐波那契值时，就是一维数组的最后最后一位，如果是二维数组，那么结果则是位于最右下角的那一位

二维应用：

题目1：给你一个字符串，如19216801这一个字符串，通过在任意位置加入三个点，组成合理的ip地址，请问，它有几种合理的方案

题意分析：

• 合理的ip地址 X.X.X.X,,并且每一位都必须小于255，拆成四位。
• ip拆成四位，数字不能以0开头。

图解：

具体部分：

图一：

图二：

图三：

---

• 由图一和图二的橙色圈圈和蓝色圈圈可知，则这道题画成一棵树，则会出现很多的重复子问题，那么用动态规划的图如下，这道题，要选择二维dp数组作为载体，来存放已解决的子问题。

• 画图注意点：

  • 1.对于一个动态规划的问题，一定要理解dp[]或dp[] []对应的含义，例如在斐波那契数列里，dp[x]就表示斐波那契数列的值，而在这道题里，我们把题目进行分解，要求将字符串拆成四个255以内的值，那么dp[] [j]就可以前j个字符串，dp[i] []则表示可以表示i个255以内的值，合起来的意思，就是前j个字符串可以表示i个255以内的值
  • 2.在画图的时候，其实也要注意，为了让我们对题目更好的理解，我们一般会多申请一个空间，从1开始。
  • 3.我们题目所要的解一般在d[max] [max]这个地方，这个题目例题要我们求的就是d[4] [8],str前8个字符能组成几种255以内的数

  动态规划图解分解过程：

  第一步：对d[i] [j]数组进行初始化，对i和j等于0的地方，可赋值为0，因为没有意义；

  比如i=0时，j=1时，表示1可以表示0个255的方法有几种，显然没意义，所以直接赋值为0；

第二步：对i=1开始分析。

• 从j=1开始看，将字符串1表示成1个255以内的数，有一种
• j=2，将字符串19表示成1个255以内的数，有一种
• j=3，将字符串192表示成1个255以内的数，有一种
• j>=4开始，就会看到已经是四位数了，大于255，所以是0

第三步：从i=2开始分析

• 由前面可知，j=1时，根据意义，1不能表示2个255以内的数，所以是0

• j=1时，要注意，从i=2开始后，不是直接看19是255以内的数，那它就是一种，这种想法是错误的，对于递归问题转动态规划，我们要看它的起源，所以j=2，先看9是不是255以内的数，则应该返回i=1那一行看，如果9是，则d[2] [2]+=d[1] [1],然后再看19是不是255以内的数，如果是，则d[2] [2]+=d[1] [0]，所以最终d[2] [2]=1.

• 

• 

  d[2] [3]+=dp[1] [1]，看192是不是255以内的数，如果是d[2] [3]+=dp[1] [0]。最终，d[2] [3]=2。

• 同理，后面的数，也是这样得出。经过多次运算，我们会发现一种规律，每一个格子的值都是当前格子左上角的三个格子之和组成，那为什么是三个格子，也不一定，看具体要求，因为这道题是不超过255，那肯定只能是三位数，所以就是三个格子。最后，组成的图如下：

• 那么我们会有一个疑问，为什么最后的答案就是我们要求。这需要我们回归树形图。拿其中一个格子来说。

• 

• 为什么这个格子是5？

  

  

  

• 仔细数数，图中蓝色的圈圈是否有5个，就说明6的起源有5个，再回归方格图，我们就会有一种感觉，如果看的是dp[3] [1]=3这个数，我们就可以去树形图里找1的起源，会有三个圈，而1所在的树的层次肯定会比6的层次高，因为1在前面，所以1会是6的子问题，所以，这棵树，与这个表结合，表从上到下的子问题的答案，到最后，我们要求的答案，而树，从上到下，每一个分支，也是一个子问题，到叶子节点，可能就是我们要找的答案。

动态规划代码：

接下来，我们来看代码实现。

int DP(string str)
{
    int len=str.length;
    int dp[5][len+1]={0};
     //进行初始化    
    for(int i=0;i<5;i++)//先对dp数组进行遍历赋值
    {
         for(int j=i;j<len;j++)
         {
             if(i==0&&j==0)//dp[0][0]置为1，后面比较好算
             {
                dp[i][j]=1;
                continue;
             }
             if(i==0)//第一行没有意义，所以为0
             {
                dp[i][j]=0;
                continue;
             }
               dp[i][j]=0;
             for(int x=1;x<=3;x++)//三位数
             {
                if(j-x>=0&&validate(str.substr(j-x+1,x)))
  //str.substr(a,b),表示从j-x+1这个地方开始截取x个字符
  //validate()这个函数是判断数字
                {
                    dp[i][j]+=dp[i-1][j-x];
                }
             }
             
         }
    }
         return dp[4][len]
};
int validate(string str)
{
   if(s=='0')  return true;
   if(s.startWith('0')) return false;
   return parseInt(s)<=255;
}
/*
库函数
str.startWith(ch)    //判断字符串是否以‘0’开头
 parseInt(str)      //是将str字符串转化为数字的函数
*/

伪代码

int DP(string str)
{
   得到字符串的长度len
   申请多一个空间的dp数组，并初始化
   
   for i=0 to i=4//对dp数组进行遍历
   {
     for j=i to j=len-1
     {
         if(i==0&&j==0)//dp[0][0]置为1，后面比较好算，不影响之前的分析
         {
           dp[i][j]=1;
           continue;
         }
         if(如果是第一行)
         {
            没有意义，则dp[i][j]=0;
            continue;
         }
         dp[i][j]=0;
         for x=1 to x=3  //三位数
         {
           if(从j-x+1这个地方开始截取x字符，并且数字有意义)
           {
              dp[i][j]+=dp[i-1][j-x];
           }
         }
         
     }
   }
}

运行结果：

题目解题优势及难点

对于上面这道题，其实也可以通过递归来实现，根据一些前辈的经验，得出了两个经验，一是只要遇到字符串的子序列或配准问题首先考虑动态规划DP， 二是只要遇到需要求出所有可能情况首先考虑用递归，但是上面这道题目，其实用动态规划也可以理解。

题目二：

• 这道题，一开始看着题目有点像是哈夫曼树求最小权值，后来发现是不一样的，这道题要求是相邻的，哈夫曼树没有这个条件，所以代码放进去是错误的。
  

解题思路：

• 步骤一，计算sum[]数组，表示第i堆石子到第j堆石子的总和

• 对sum[i]数组里，我们可以横着看每一行，i=1时，从j=1开始，代表的意义就是如果从第一个石子往右开始合并，先不计较到底要怎么合并花费比较小，从第二行开始，代表的意义就是从第二个石子开始从左往右合并，不考虑开销，这样，就可以罗列出所有合并的可能性，那么我们得出所有可能性后，要做的就是，让这些可能性进行关联，找出最小开销。
• 那么对下面第二行，第三行也是同理的。

代码实现：

---

上面的步骤，其实只是对这些石子所有可能性进行一个存储，所以，接下来，要进入核心代码的部分，真正进行dp[] []数组的操作。

伪代码：

for i=1 to i=N
  for j=i to j=N
    计算把第i堆合并到第j堆需要的费用
     用sum数组存储
for j=2 to j=N
{
    for i=j to j=0
    {
        先对dp[i][j]初始化为无穷大
        for k=i to k=j-1
        {
           从i到j共有j-i个状态,取最优值
           dp[i][j]=min(dp[i][j],dp[i] [k]+dp[k+1][j]+sum[i][j]);
        }
    }
}

运行结果：

DP过程：

以归并石子的长度为阶段，一共有n-1个阶段

状态：每个阶段有多少堆石子要归并

当归并长度为2时，有n-1个状态，分别为1和2合并，2和3合并.....n-1和n合并

当归并长度为3时，有n-2个状态，分别为1，2，3合并，2，3，4合并.....

当归并长度为n时，有1个状态

让我们看看上面的代码：

j=2,i=1

j=3,i=2

j=3,i=1

j=4,i=3

j=4,i=2

j=4,i=1

从上面的变化，其实我们可以看到，代码在算从i到j分别算出合并两个，三个，，这样算下去，含义就是从第i堆到第j堆，算出不同状态下的dp值

图解如下：

• 首先，对dp[i] [j]进行初始化。

• 对于动态规划，我们要知道，最核心的部分，就是能够找到dp[i] [j]横坐标，纵坐标表示的含义。

• 对于此题，dp[i] [j]表示的含义其中一种是就是从第i堆合并到第j堆的最小代价。

• j=i，表示自己合并自己，不用花费任何钱
• 第二步，将两堆合并成一堆需要的费用。

• 第三步，将三堆合并成一堆，这里可能会感到疑惑的是为什么是三堆，我们已经解决了相邻两堆之间的问题，那么在三堆之间，我们则要对当前对进行分析，是要选右边的并成一堆，还是选左边的并成一堆，所以，肯定是选和比较小的，所以还记得我们之前做的准备sum数组嘛，它记录了每一堆从左往右要花费的钱钱，这时，它就起了作用。

• 对于i=1，j=3这个点来说,它的含义就是将第一堆（1），第二堆（2），第三堆（3）合并在一起，那么总的费用就是第一堆和第二队进行合并cost1=3，12堆和3进行合并，就是cost2=3+3=6，所以总的费用就是3+6=9。
• 那么下面对于i=2，j=4也是同理

最后

• 我们来举个例子吧

• 看表里的i=2，j=4,结合代码，含义是把第二堆第三堆第四堆进行合并

• k=2时，dp[2] [2]+dp[3] [4]+sum[2] [4]

• k=3时，dp[2] [3]+dp[4] [4]+sum[2] [4]

• 从上面就可看到，dp[2] [4]有两种选择，第三堆和第四堆先合并，再和第二堆进行合并，或者第二堆和第三堆先合并，再合并第四堆，然后比较它们之间的大小，就可以求出正解

题目解题的优势及难点

这次我选的题目都是关于动态规划的，所有优势大都差不多，就不说了，动态规划的题目看多了，我觉得这道题给我的感觉就更多是枚举的感觉，通过二维数组来存储，其实，也是这道题让我写了这个全部都是动态规划的题目，因为一开始还不懂什么是动态规划，就碰上了这个题目，当时在那边死命的看这道题的题解，就是死命的看不懂，那在这之前，其实对动态规划有所耳闻，只是并没有非常认真地了解过，所以，就打算多找几道题，让我熟悉一下它

题目三：环形相邻两堆石子合并

解题思路：

• 环形结构，经常采用双倍长度线性化的手段，也就是说，把环形结构看成是长度为环的两倍的两倍的线性结构来处理，将环化成线性结构

• 环的长度是N，所以题目相当于与有一排石子，1，，，，N,N+1，，，2N,然后就可以用线性的石子合并问题的方法做了

• 有个地方需要注意，f（i,j)总是和f(N+i,N+j)相等，所以可以减少一些不必要的计算。

• 将N结构的线性表，转换成双倍的2N结构的长度。然后在2N长度的表中，截取我们需要的长度N的部分就可以了

状态：

• dp[i] [j]表示从第i堆合并到第j堆（合并成一堆）的最小代价

• sum[i]表示前i堆石子的和

• 状态转移方程：

• dp[i] [j]=min(dp[i] [k]+dp[(i+k+1)%n] [j-k-1]+sum[i] [j])(0<k<=j-1)(j<=k<j)

dp过程：

• len...1>n len表示归并长度
• i...1>2n i表示起点
• 那么j=i+len-1
• k...i>j-1

根据上面，就可以知道说，转换成线性结构后，和题目二是差不多的

代码实现：

伪代码

for i=1 to i=N
  for j=i to j=N
    计算把第i堆合并到第j堆需要的费用
    用sum数组存储
for j=1 to j=n-1
  for i=0 to i=n-1
  {
      对mins[i][j]初始化为无穷大
      for k=0 k=j-1
      {
          计算从i到j共有j-i个状态,取最优值
      }
  }
   

图解如下：

这个是用vs调试出来的结果

下面，对上面的数据进行分析

• 从第二列开始看
• i=0,j=1,表示第0堆与第一堆进行合并（由于数据存储的时候，是从下标为0开始，但是如果从下标为一 开始，可能更好理解）
• 接下来的一列，都是这个意思
• 从第三列开始看
• i=0，j=2表示将第0堆，第一堆，第二堆进行合并，此时有两种状态，上面也已经说过了
• 总的来说，这道题的思路和上面一道一样，唯一的不同就是处理时，要用%进行求余，可以减少一定的计算时间。

运行结果：

题目解题的优势及难点

其实会发现，这题看多了，到最后一道题，再看的时候，就没那么难了，这最后一道题，我觉得最重要的是懂得环路处理起来的思路，其实想想我们上学期学过的数组左移右移这样，也是可以通过求余来算的，我上次看过一个视频，对于程序员，如何高效刷题，他说的是，对于同一类的题目应该给他刷个十几二十题的，并且可以有小本本记录下每一个超级经典，自己又容易错的，同样的题目看多了，遇到面试官的那些奇葩题目，都是万变不离其宗，也就不会慌了。