这是一个记忆和DP从斐波那契数问题写在Java的例子。

这里的动态编程不涉及递归，因为它不受执行堆栈的限制，所以结果更快，可以计算出更高的值。

public class Solution {

 public static long fibonacciMemoization(int i) {
    return fibonacciMemoization(i, new long[i + 1]);
 }

 public static long fibonacciMemoization(int i, long[] memo) {
    if (i <= 1) {
        return 1;
    }
    if (memo[i] != 0) {
        return memo[i];
    }
    long val = fibonacciMemoization(i - 1, memo) + fibonacciMemoization(i - 2, memo);
    memo[i] = val;
    return val;
 }

 public static long fibonacciDynamicPrograming(int i) {
    if (i <= 1) {
        return i;
    }
    long[] memo = new long[i + 1];
    memo[0] = 1;
    memo[1] = 1;
    memo[2] = 2;
    for (int j = 3; j <= i; j++) {
        memo[j] = memo[j - 1] + memo[j - 2];
    }
    return memo[i];
 }

 public static void main(String[] args) {
    System.out.println("Fibonacci with Dynamic Programing");
    System.out.println(fibonacciDynamicPrograming(10));
    System.out.println(fibonacciDynamicPrograming(1_000_000));

    System.out.println("Fibonacci with Memoization");
    System.out.println(fibonacciMemoization(10));
    System.out.println(fibonacciMemoization(1_000_000)); //stackoverflow exception
 }
}

想想两种方法，

我们把大问题分解成小问题——自顶向下的方法。 我们从最小的子问题开始，到达更大的问题——自下而上的方法。

在Memoization中，我们使用(1.)，我们将每个函数调用保存在缓存中，并从那里进行回调。它有点昂贵，因为它涉及到递归调用。

在动态规划中，我们使用(2.)来维护一个表，通过使用保存在表中的数据(通常称为dp-table)自底向上解决子问题。

注意:

两者都适用于具有重叠子问题的问题。 由于递归函数调用期间涉及的开销，内存相对于DP执行得较差。 渐近时间复杂度保持不变。

(1)从概念上讲，记忆和DP其实是一回事。因为:考虑DP的定义:“重叠子问题”和“最优子结构”。记忆完全具备这两点。

(2)在递归较深的情况下，记忆是DP方法，存在栈溢出风险。DP自下而上没有这种风险。

(3)记忆需要一个哈希表。额外的空间和查找时间。

为了回答这个问题:

-从概念上讲，(1)意味着它们是一样的东西。

-考虑(2)，如果你真的想，记忆化是DP的一个子集，从某种意义上说，可以通过记忆化解决的问题可以通过DP解决，但是可以通过DP解决的问题可能无法通过记忆化解决(因为它可能会堆栈溢出)。

把(3)考虑在内，它们在性能上有微小的差异。

编程相关文章。指南:动态规划vs记忆vs制表

记忆和动态规划的区别是什么?

记忆是描述一种优化技术的术语，在这种技术中缓存以前计算的结果，并在再次需要相同的计算时返回缓存的结果。

动态规划是一种迭代求解递归性质问题的技术，适用于子问题的计算重叠的情况。

动态编程通常使用制表实现，但也可以使用记忆实现。所以你可以看到，两者都不是另一个的“子集”。

一个合理的后续问题是:制表(典型的动态编程技术)和记忆之间的区别是什么?

当你用制表法解决一个动态规划问题时，你是“自底向上”地解决问题，也就是说，首先解决所有相关的子问题，通常是填满一个n维表。根据表中的结果，然后计算“顶部”/原始问题的解决方案。

如果您使用记忆来解决问题，您可以通过维护已经解决的子问题的映射来实现。从“自顶向下”的意义上说，首先解决“顶部”问题(通常递归向下解决子问题)。

这里有一个很好的幻灯片(链接现在死了，但幻灯片仍然很好):

If all subproblems must be solved at least once, a bottom-up dynamic-programming algorithm usually outperforms a top-down memoized algorithm by a constant factor No overhead for recursion and less overhead for maintaining table There are some problems for which the regular pattern of table accesses in the dynamic-programming algorithm can be exploited to reduce the time or space requirements even further If some subproblems in the subproblem space need not be solved at all, the memoized solution has the advantage of solving only those subproblems that are definitely required

额外的资源:

维基百科:记忆，动态规划 相关SO Q/A:动态规划的记忆或制表方法

记忆和动态规划都只解决单个子问题一次。

记忆化使用递归并自顶向下工作，而动态规划则相反，自底向上解决问题。

下面是一个有趣的类比

自上而下-首先你说我将接管世界。你会怎么做呢?你说我会先拿下亚洲。你会怎么做呢?我会先接管印度。我会成为德里的首席部长，等等。

自下而上——你说我会成为德里的首席部长。然后我会接管印度，然后是亚洲所有其他国家，最后我会接管全世界。

这是一个记忆和DP从斐波那契数问题写在Java的例子。

这里的动态编程不涉及递归，因为它不受执行堆栈的限制，所以结果更快，可以计算出更高的值。

public class Solution {

 public static long fibonacciMemoization(int i) {
    return fibonacciMemoization(i, new long[i + 1]);
 }

 public static long fibonacciMemoization(int i, long[] memo) {
    if (i <= 1) {
        return 1;
    }
    if (memo[i] != 0) {
        return memo[i];
    }
    long val = fibonacciMemoization(i - 1, memo) + fibonacciMemoization(i - 2, memo);
    memo[i] = val;
    return val;
 }

 public static long fibonacciDynamicPrograming(int i) {
    if (i <= 1) {
        return i;
    }
    long[] memo = new long[i + 1];
    memo[0] = 1;
    memo[1] = 1;
    memo[2] = 2;
    for (int j = 3; j <= i; j++) {
        memo[j] = memo[j - 1] + memo[j - 2];
    }
    return memo[i];
 }

 public static void main(String[] args) {
    System.out.println("Fibonacci with Dynamic Programing");
    System.out.println(fibonacciDynamicPrograming(10));
    System.out.println(fibonacciDynamicPrograming(1_000_000));

    System.out.println("Fibonacci with Memoization");
    System.out.println(fibonacciMemoization(10));
    System.out.println(fibonacciMemoization(1_000_000)); //stackoverflow exception
 }
}