思想:

「分治思想」、「空间换时间」、「最优解」等多种算法思想

动态规划特点:

「分治」是算法中的一种基本思想，其通过将原问题分解为子问题，不断递归地将子问题分解为更小的子问题，并通过组合子问题的解来得到原问题的解。

类似于分治算法，「动态规划」也通过组合子问题的解得到原问题的解。不同的是，适合用动态规划解决的问题具有「重叠子问题」和「最优子结构」两大特性。

重叠子问题

动态规划的子问题是有重叠的，即各个子问题中包含重复的更小子问题。若使用暴力法穷举，求解这些相同子问题会产生大量的重复计算，效率低下。

动态规划在第一次求解某子问题时，会将子问题的解保存；后续遇到重叠子问题时，则直接通过查表获取解，保证每个独立子问题只被计算一次，从而降低算法的时间复杂度。

斐波那契数列(重叠子问题示例)

「暴力递归」→→「记忆化递归」→→「动态规划」

int fibonacci(int n) {if (n == 0) return 0; // 返回 f(0)if (n == 1) return 1; // 返回 f(1)return fibonacci(n - 1) + fibonacci(n - 2); // 分解为两个子问题求解
}

记忆递归:一个函数初始化数组存储数值,一个函数返回

int fibonacci(int n, vector<int> dp) 
{if (n == 0) return 0;           // 返回 f(0)if (n == 1) return 1;           // 返回 f(1)if (dp[n] != 0) return dp[n];   // 若 f(n) 以前已经计算过，则直接返回记录的解dp[n] = fibonacci(n - 1, dp) + fibonacci(n - 2, dp); // 将 f(n) 则记录至 dpreturn dp[n];
}// 求第 n 个斐波那契数
int fibonacciMemorized(int n) 
{vector<int> dp(n + 1, 0); // 用于保存 f(0) 至 f(n) 问题的解return fibonacci(n, dp);
}

动态递归**

这个就很妙,看起来像是和前面的一样,实则就是利用一个数组来实现状态转移

// 求第 n 个斐波那契数
int fibonacci(int n) {if (n == 0) return 0;          // 若求 f(0) 则直接返回 0vector<int> dp(n + 1, 0);      // 初始化 dp 列表dp[1] = 1;                     // 初始化 f(0), f(1)for (int i = 2; i <= n; i++) { // 状态转移求取 f(2), f(3), ..., f(n) dp[i] = dp[i - 1] + dp[i - 2];}return dp[n];                  // 返回 f(n)
}
/

上述动态规划解法借助了一个 dp 数组保存子问题的解，其空间复杂度为 O(N)

而由于 f(n) 只与 f(n−1) 和 f(n−2) 有关，因此我们可以仅使用两个变量 a , b 交替前进计算即可。此时动态规划的空间复杂度降低至 O(1)

// 求第 n 个斐波那契数
int fibonacci(int n) {if (n == 0) return 0;           // 若求 f(0) 则直接返回 0int a = 0, b = 1;               // 初始化 f(0), f(1)for (int i = 2; i <= n; i++) {  // 状态转移求取 f(2), f(3), ..., f(n) int tmp = a;a = b;b = tmp + b;}return b;                       // 返回 f(n)
}

这里第二种方法已经有点失去KISS了,因为他已经把简单的思想给优化了一下利用O(1)空间,可能稍微有点看不懂,自己在纸上画几下就懂啦

「以上内容参考《算法导论》与《算法与数据结构》」