五大经典算法之动态规划

一、概念起源

  动态规划，又名DP算法（取自其Dynamic Programming的缩写），最初是运筹学的一个分支，是用来求解决策过程最优化的数学方法。

二、基本思想

  把 多阶段过程 转化为一系列单阶段过程，利用各阶段之间的关系，逐个求解。那什么叫多阶段过程呢？

多阶段过程：首先大家可以思考一下以下这个问题：

假如我们有面值为1元/3元/5元的硬币若干枚，如何用最少的硬币凑够137元？

当然我们可以使用暴力枚举解决这个问题，不够那样复杂度就太高了。我们可以这样考虑，凑齐137元可以看成一个最终目标，我们可以把它细分为先以最少的硬币数量凑齐136元（这样再加1元就137元了）或是133元或是132元 + 1次。然后我们的问题转变为了先以最少的硬币数量凑齐136元或是133元或是132元。看似问题数量变更多了，但是实际问题难度却变小了。
而且这种细分方式可以不断细分，一直细分到接近于0元。而在这个思维过程中，我们就是将解决137元的问题分阶段的完成，而这个过程就叫做 多阶段过程 。

三、解题步骤(思路)

1. 利用动态规划思想从上往下思考问题：将多阶段问题转变成更小的多阶段问题（状态转移方程）
2. 分解至最小的单阶段问题（可直接解决问题）。
3. 利用循环从下往上解决问题。

四、算法框架

相对于其他基本算法，动态规划算法比较灵活，其主体框架取决于其具体问题，具体问题决定具体的状态转移方程；因此，其不像回溯法有一套“亘古不变”的算法框架；所以以下的算法只能说是解决类似上述硬币问题的DP算法框架，只能算是给各位抛砖引玉。

 变量解释：

  res：存储各阶段问题的答案

  n：最终问题的标记位

  i：循环的索引

  f：某阶段问题的答案与前些阶段问题答案之间的函数关系

void dp(int n) {
  // 定义问题的解数组
  int res[n + 1];
  // 初始化最小的单阶段问题的解
  res[1] = 1 ...
  // 从初始化后的解数组的第一个位置开始循环计算res[i]
  int i = inital;
  while (i <= n) {
    // f函数取决于状态转移方程
    res[i] = f(res[i - 1], res[i - 2], res[i - 3]...);
    i++;
  }
  return res[n];
}  

五、经典实现

经典问题：Best Time to Buy and Sell Stock

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Note that you cannot sell a stock before you buy one.

Example 1:

Input: [7,1,5,3,6,4]

Output: 5

Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Not 7-1 = 6, as selling price needs to be larger than buying price.
Example 2:
Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.

int maxProfit(int* prices, int pricesSize) {
  if (pricesSize == 0) {
    return 0;
  }
  int res[pricesSize];
  int min[pricesSize];
  res[0] = 0;
  min[0] = prices[0];
  int i = 1;
  while (i < pricesSize) {
    if (res[i - 1] < prices[i] - min[i - 1]) {
      res[i] = prices[i] - min[i - 1];
    } else {
      res[i] = res[i - 1];
    }
    if (prices[i] < min[i - 1]) {
      min[i] = prices[i];
    } else {
      min[i] = min[i - 1];
    }
    i++;
  }
  return res[pricesSize - 1];
}