算法：动态规划第一讲（Dynamic Programming）

DP定义：

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

动态规划的三个特点

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

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

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

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

状态定义的要求：定义的状态一定要形成递推关系。
一句话概括：三特点四要素两本质

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

第一题 Fibonacci

Fibonacci牛客链接

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0，第1项是1）。
n<=39

问题解决

方法一：递归（在这里我就不再介绍了）

public class Solution {
  public int Fibonacci(int n) {
    // 初始值
    if(n <= 0)
      return 0;
    if(n == 1 || n == 2)
      return 1;
    // F(n)=F(n-1)+F(n-2)
    return Fibonacci(n - 1) + Fibonacci(n - 2);
 }
}
/*
递归的方法时间复杂度为O(2^n)，随着n的增大呈现指数增长，效率低下
当输入比较大时，可能导致栈溢出
在递归过程中有大量的重复计算
*/

方法二：动态规划
问题：数列第n项的值
状态F(i) ：数列第i项的值
状态递推：F(n)=F(n-1)+F(n-2)
初始值：F(0)=F(1)=1
返回结果：F(N)

public class Solution {
  public int Fibonacci(int n) {
    // 初始值
    if(n <= 0)
      return 0;
    // 申请一个数组，保存子问题的解，题目要求从第0项开始
    int[] array = new int[n + 1];
    array[0] = 0;
    array[1] = 1;
    for(int i = 2; i <= n; ++i)
   {
      // F(n)=F(n-1)+F(n-2)
      array[i] = array[i - 1] + array[i - 2];
   }
    return array[n];
 }
}
/*
上述解法的空间复杂度为O(n)
其实F(n)只与它相邻的前两项有关，所以没有必要保存所有子问题的解
只需要保存两个子问题的解就可以
下面方法的空间复杂度将为O(1)
*/

如果不想申请空间只保存第n项则可以看下边代码:

public class Solution {
    public int Fibonacci(int n) {
       int fn1 = 0;
       int fn2 = 1;
        if(n == 0 || n==1) {
            return n;
        }
       int fn = 1;
       while(n-- > 1) {
           fn = fn1 + fn2;
           fn1 = fn2;
           fn2 = fn;
       }
        return fn;
    }
}

第2题 变态青蛙跳台阶(Climbing Stairs)

变态青蛙跳台阶牛客链接

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

问题解决

动态规划：
问题：跳上n阶台阶的方法数
状态f(i) ：跳上第i阶台阶的方法数
状态递推：
f(n) = f(n-1)+f(n-2)+…+f(0) //在这里f（0）是辅助的一项值取1
f(n-1) = f(n-2)+…+f(0)
上边两式子进行变换得最终的状态方程为：
f(n) = 2*f(n-1)
初始值：f(0)=f(1)=1
返回结果：f(n)

F(4)相当于之前站在第1，2，3级上跳，再加上直接跳4级台阶。

public class Solution {
  public int JumpFloorII(int target) {
    int ret = 1;
    for(int i = 2; i <= target; ++i){
      ret *= 2;
   }
    return ret;
 }
}

扩展：降低时间复杂度
上述实现的时间复杂度:O(N)
O(1)的实现：使用移位操作

public class Solution {
    public int JumpFloorII(int target) {
        return 1 << (target -1);
    }
}

扩展1：一次只能跳1阶或者2阶，现在该如何解答

跳台阶牛客链接

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

问题解决

状态递推：F(n)=F(n-1)+F(n-2)
代码同斐波那契数列

扩展2：矩形覆盖

矩形覆盖牛客链接

题目描述

我们可以用21的小矩形横着或者竖着去覆盖更大的矩形。请问用n个21的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

问题解决

状态F(i) 用i个21矩形覆盖 2i 的大矩形
状态递推：F(n)=F(n-1)+F(n-2)

F(n)的前一个状态可能有两种为：

代码同斐波那契数列

第3题 最大连续子数组和(Maximum Subarray)

题目链接

题目描述

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。给一个数组，返回它的最大连续子序列的和，你会不会被他忽悠住？(子向量的长度至少是1)

问题解决

动态规划：
问题：数组的最大连续和
子问题：局部元素构成数组，它的最大连续和
状态F(i) ：以第i个元素结尾的最大连续子序列和
状态递推：

F(i) = max(F(i-1) + array[i]，array[i])
初始值：f(0)=array[0]
返回结果：max(maxsum，F(i))

public class Solution {
  public int FindGreatestSumOfSubArray(int[] array) {
    // F(i)初始化 maxsum初始化
    int maxSum = array[0], curSum = array[0];
    for(int i = 1; i < array.length; ++i) {
      //F(i) = max(F(i-1) + array[i]，array[i])
      curSum = Math.max(curSum + array[i], array[i]);
      // maxsum = max( maxsum，F(i))
      if(curSum > maxSum)
        maxSum = curSum;
   }
    return maxSum;
 }
 }

第4题 字符串分割(Word Break)

题目链接

题目描述

给定一个字符串s和一组单词dict，判断s是否可以用空格分割成一个单词序列，使得单词序列中所有的单词都是dict中的单词（序列可以包含一个或多个单词）。
例如:
给定s=“nowcode”；
dict=[“now”, “code”].
返回true，因为"nowcode"可以被分割成"now code".

问题解决

方法：动态规划
状态：单词是否可以被成功分割
子状态：前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)

import java.util.Set;
public class Solution {
  public boolean wordBreak(String s, Set<String> dict) {
    boolean[] canBreak = new boolean[s.length() + 1];
    // 初始化F(0) = true
    canBreak[0] = true;
    for(int i = 1; i <= s.length(); ++i){
      for(int j = i - 1; j >= 0; --j){
        // F(i): true{j <i && F(j) && substr[j+1,i]能在词典中找到} OR false
        // 第j+1个字符的索引为j
        if(canBreak[j] && dict.contains(s.substring(j,i))){
          canBreak[i] = true;
          break;
       }
     }
   }
    return canBreak[s.length()];
 }
}