概述：
算法的重要性是不言而喻的。
可能是你会不屑于听这样的话，是因为在我们的实际开发中，用到算法的地方真是太少了。对于这一点我并不否认，因为对于一个初级的开发者而言，算法显得太过高深了。如果我们想去实现一个功能，通常的做法就是百度或是Google。这就是为什么会有那么一句调侃之辞：我们不生产代码，我们只是代码的搬运工。
当我们已经完成了初级开发者的这一过程时，我们应该想着怎么去优化自己的代码，从而让自己的代码更加优美，也更显B格。
动规的使用场景：
动态规划是对回溯算法的一种改进。
我们知道回溯的一个致命缺点是它的重复计算，在后面的例子中我也会通过实例来说明这一点，而动规则规避了这个问题。动规的核心是状态和状态转移方程。
示例例举及过程说明：
1.数字三角形
问题描述：
有一个由非负整数组成的三角形，第一行只有一个数，除了最后一行之外每个数的左下方和右下方各有一个数。
从第一行的数开始，每次可以往下或右下走一格，直到走到最后一行，把沿涂经过的数全部加起来。如何走才能使得这个数尽可能的大？
思路梳理：
对于这样一个问题，可能大家想到的第一个解法就是递归。对于递归，我们不用想太多。因为当我们想要知道第(i, j)处的最大值时，是要依赖第(i + 1， j)和第(i + 1, j + 1)个节点的最大值。以此类推，如是我们就可以使用递归和递推来实现。
递归求解（关键代码）
/** * 通过回溯法获得第(i, j)处的最大值 * @author Aaron * 2015年8月2日 */ private static int getNodeMaxByRecall(int[][] m, int i, int j) { int max = Integer.MIN_VALUE; System.out.println("m[" + i + "][" + j + "]"); max = m[i][j] + (i == m.length - 1 ? 0 : Math.max(getNodeMaxByRecall(m, i + 1, j), getNodeMaxByRecall(m, i + 1, j + 1))); return max; } /** * 回溯法求解 * @author Aaron * 2015年8月1日 */ public static void calculateByRecall(int[] a) { int[][] m = getMatrix(a); int max = getNodeMaxByRecall(m, 0, 0); System.out.println("max[0][0] = " + max); } 可以看到，递归求解时是一种自顶向下的求解方式。它是在按需去计算。 在递归中，比如说我们的意图是去求解max(i, j)，当我们知道需要求解max(i, j)，就必须知道max(i + 1, j)和max(i + 1, j + 1)时，我们才去求解max(i + 1, j)和max(i + 1, j + 1).
可是，这种按需求解的过程，无法让我们知道，再要计算的点是否已经计算过了。下面是这个程序在递归的过程中计算过的节点过程：
可以看到，这里有一些节点是被重复计算的。
递推法求解（关键代码）：
/** * 通过递推法获得第(i, j)处的最大值 * @author Aaron * 2015年8月2日 */ private static int getNodeMaxByRecursion(int[][] m, int i, int j) { int max = Integer.MIN_VALUE; System.out.println("m[" + i + "][" + j + "]"); max = m[i][j] + (i == m.length - 1 ? 0 : Math.max(m[i + 1][j], m[i + 1][j + 1])); return max; } /** * 递推法求解 * @author Aaron * 2015年8月2日 */ private static void calculateByRecursion(int[] a) { int[][] m = getMatrix(a); for (int i = m.length - 1; i >= 0; i--) { for (int j = 0; j <= i; j++) { m[i][j] = getNodeMaxByRecursion(m, i, j); } } int max = m[0][0]; System.out.println("max[0][0] = " + max); } 可以看到，递推求解时是一种自底向上的求解方式。它是在预先计算。 在递推中，比如说我们的意图是去求解max(i, j)，当我们知道需要求解max(i, j)，就必须知道max(i + 1, j)和max(i + 1, j + 1)时，不过这个时候，我们的max(i + 1, j)和max(i + 1, j + 1)已经计算出来了，这个时候我们就不用再去计算了.
在递推的计算过程中，因为我们是自底向上的求解，所以我们并不知道这个节点是否会被使用到，而如果这个节点需要被使用，我们也不会重复计算这个值，因为已经计算过，并已经保存下来了。不过，这个过程中，每个节点都会被计算一次，不管会不会被使用（虽然这个程序中是都被使用了）。
记忆化求解（关键代码）：
/** * 通过记忆化搜索获得第(i, j)处的最大值 * @author Aaron * 2015年8月2日 */ private static int getNodeMaxByMemory(int[][] m, int[][] d, int i, int j) { if (d[i][j] >= 0) { return d[i][j]; } System.out.println("m[" + i + "][" + j + "]"); d[i][j] = m[i][j] + (i == m.length - 1 ? 0 : Math.max(getNodeMaxByMemory(m, d, i + 1, j), getNodeMaxByMemory(m, d, i + 1, j + 1))); return d[i][j]; } /** * 记忆化搜索 * @author Aaron * 2015年8月2日 */ private static void calculateByMemory(int[] a) { int[][] m = getMatrix2(a); int[][] d = initMatrix(m.length); int max = getNodeMaxByMemory(m, d, 0, 0); System.out.println("max[0][0] = " + max); } 记忆化搜索是基于递归来进行的。因为我们想做一件事，来避免之前在递归中的重复计算。在学习算法的复杂度的时候，我们知道复杂度分为两种，一种是时间复杂度，一种是空间复杂度。这两种复杂度是有一个平衡的。也就是说我们想要在时间上优化，那么空间上就得做出牺牲。这里也正是使用了牺牲空间来换取时间的优先。 下面是各个节点被计算的过程：
这里可以看到，我们的每个节点也是只被计算了一次。节省了时间。
2.钢条切割
问题描述：
给定一段长度为n英寸的钢条和一个价格表p(i)，求切割钢条的方案，使得销售收益r(n)最大。注意，如果长度为n英寸的钢条的价格为p(n)足够大，最优解可能不是完全不需要切割。
价格表：
看到这一个问题，不知道大家是不是也跟我一样，第一感觉是可以使用贪心试一下。可是细想之后又发现行不通，因为这里面如果按不同的方式切割钢条，那么切割成的两份都是可变的量，不好控制。
按照上面的思路，我们可以使用两种方法来试着解决这一问题：
递归（关键代码）：
/** * 计算长度为n的钢条的最佳切割方案(递归) * @author Aaron * 2015年8月3日 */ private static int getMax(int[] p, int n) { System.out.println(n); if (n <= 0) { return 0; } int max = Integer.MIN_VALUE; for (int i = 1; i <= n; i++) { max = Math.max(max, p[i - 1] + getMax(p, n - i)); } return max; } /** * 通过递归计算钢条的切割算法 * @author Aaron * 2015年8月3日 */ private static void calculateMaxByRecursive(int n) { initPriceList(); int[] p = {1, 5, 8, 9, 10, 17, 17, 20, 24, 30}; int max = getMax(p, n); System.out.println("max = " + max); } 记忆化搜索（关键代码）：
private static int[] getRecordArray(int n) { if (n <= 0) { return null; } int[] r = new int[n]; for (int i = 0; i < n; i++) { r[i] = Integer.MIN_VALUE; } return r; } /** * 计算长度为n的钢条的最佳切割方案(记忆化搜索) * @author Aaron * 2015年8月3日 */ private static int getMaxByMemory(int[] p, int n, int[] r) { if (n <= 0) { return 0; } if (r[n] >= 0) { return r[n]; } System.out.println(n); int max = Integer.MIN_VALUE; for (int i = 1; i <= n; i++) { max = Math.max(max, p[i - 1] + getMaxByMemory(p, n - i, r)); } r[n] = max; return max; } /** * 通过记忆化搜索计算钢条的切割算法 * @author Aaron * 2015年8月3日 */ private static void calculateMaxByMemory(int n) { initPriceList(); int[] p = {1, 5, 8, 9, 10, 17, 17, 20, 24, 30}; int[] r = getRecordArray(n + 1); int max = getMaxByMemory(p, n, r); System.out.println("max = " + max); } 完整源代码下载：