动态规划思想

动态规划，无非就是利用历史记录，来便面我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存。下面我们先来讲下做动态规划题很重要的三个步骤，

如果你听不懂，也没关系，下面会有很多例题讲解，估计你就懂了。之所以不配合例题来讲这些步骤，也是为了怕你们脑袋乱了

第一步骤：；定义数组元素的含义，上面说了，我们会用一个数组，来保存历史记。

第二：找出数组元素之间的关系式，我觉得动态规划，还是有一点类似于我们高中学习时的归纳法的，当我们要计算dp[n]时，是可以利用dp[n-1], dp[n-2]…dp[1]，来推出dp[n]的，也就是可以利用历史数据来推出新的元素值，所以我们要找出数组元素之间的关系式，例如dp[n] = dp[n-]+dp[n-2], 这个就是他们的关系了。而这一步，也是最难的一步，后面我会讲集中类型的题来说。

第三： 找出初始值。学过数学归纳法的都知道，虽然我们知道了数组元素之间的关系，例如：dp[n] = dp[n-]+dp[n-2]，我们可以通过 dp[n-]+dp[n-2]来计算dp[n]，但是，我们得知道初始值啊，例如一直推下去的话，会由dp[3] = dp[2] + dp[1]。而 dp[2] ，dp[1]和dp[2]是不能再分解的了，所以我们必须要能够直接获得dp[2]和dp[1]的值，而这，就是所谓的初始值。

由了初始值，并且有了数组元素之间的关系式，那么我们就可以得到 dp[n] 的值了，而 dp[n] 的含义是由你来定义的，你想求什么，就定义它是什么，这样，这道题也就解出来了。

案例一、简单的一维 DP

问题描述：一只青蛙一次可以跳上一级台阶，也可以跳上2级。求该青蛙跳上一个n级总共有多少从跳法。

（1）定义数组元素的含义

按我上面的步骤说的，首先我们来定义dp[i]的含义，我们的问题是要求青蛙跳上n级的台阶总共有多少种跳法，那么我们定义一维数组dp[i]的含义为：跳上一个i级的台阶总共有dp[i]种跳法。这样，我们能够算出dp[n]，不就是我们要求的答案吗？所以第一步定义完成。

（2）找出数组元素间的关系式

我们的目的是要求dp[n]，动态规划的题，如你们经常听说的那样，就是把一个规模比较大的问题分成几个规模比较小的问题，然后由小的问题推导出大的问题。也就是说，dp[n]的规模为n，比他规模小的是n-1, n-2, n-3… 也就是说，dp[n]一定会和dp[n-1], dp[n-2] …存在某种关系的。

对于这道题，由于情况可以选择跳一级，可以两级，所以青蛙到达第n级的台阶有两种方式

一种是从第n-1级跳上来

一种是从第n-2级跳上来

由于我们是要算所有可能的跳法的，所以有dp[n] = dp[n-1] + dp[n-2]。

（3）找出初始条件

当n=1时， dp[1] = dp[0] + dp[-1], 若我们是数组不允许下标为负数的，所以对于dp[1]，我们必须要直接给出它的数值，相当于初始值，显然，dp[i] = 1。一样，dp [0] = 0 。于是得出初始值：

dp[0] = 0 dp[1] = 1 级n<=1时，dp[n] = n

[70] 爬楼梯

int f( int n ){
    if(n <= 1)
    return n;
    // 先创建一个数组来保存历史数据
    int[] dp = new int[n+1];
    // 给出初始值
    dp[0] = 0;
    dp[1] = 1;
    // 通过关系式来计算出 dp[n]
    for(int i = 2; i <= n; i++){
        dp[i] = dp[i-1] + dp[i-2];
    }
    // 把最终结果返回
    return dp[n];
}

答是有问题的，还是错的，错在对初始值的寻找不够严谨，这也是我故意这样弄的，意在告诉你们，关于初始值的严谨性。例如对于上面的题，当 n = 2 时，dp[2] = dp[1] + dp[0] = 1。这显然是错误的，你可以模拟一下，应该是 dp[2] = 2。

[62] 不同路径

    public int uniquePaths(int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        //定义数组保存历史数据 当机器人从左上角走到(i, j)这个位置时，一共有dp[i][j]种路径
        int[][] dp = new int[m][n];

        // 如果 i 或者 j 有一个为 0，那么还能使用关系式吗？答是不能的，因为这个时候把 i - 1 或者 j - 1，就变成负数了，数组就会出问题了，所以我们的初始值是计算出所有的 dp[0] [0….n-1] 和所有的 dp[0….m-1] [0]。这个还是非常容易计算的，相当于计算机图中的最上面一行和左边一列。因此初始值如下：
        //
        //dp[0] [0….n-1] = 1; // 相当于最上面一行，机器人只能一直往右走
        //
        //dp[0…m-1] [0] = 1; // 相当于最左面一列，机器人只能一直往下走
        for (int i = 0; i < m; i++) {
            dp[i][0] = 1;
        }
        for (int i = 0; i < n; i++) {
            dp[0][i] = 1;
        }

        //找出关系数组元素间的关系式
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }

内聚性

内聚性又称块内联系。指模块的功能强度的度量，及一个模块内部各个元素彼此结合的精密程度的度量。

若一个模块内各元素（语名之间，程序段之间的联系越紧密，则它的内聚性就越高。

所谓高内聚是指一个软件模块是有相关性很强的代码组成、只负责一项任务，也就是常说的单一责任原则。

1. 偶然内聚：一个模块内的各处理元素之间没有任何联系，只是偶然的凑到一起。
2. 逻辑内聚：这种模块把几种相关的功能组合在一起，每次被调用时，由传送给模块参数来确定该模块应完成哪一种功能。
3. 时间内聚：把需要同时执行的动作组合在一起形成的模块成为时间内聚模块。
4. 过程内聚：构建或者操作的组合方式是，允许在调用前面的构件或操作之后，马上调用后面的构件或操作，即使两者之间没有数据进行传递。简单地说就是如果一个模块内的处理元素是相关的，而且必须以特定次序执行则成为过程内聚。
5. 通信内聚：
6. 顺序内聚
7. 功能内聚：：模块内所有元素的各个组成部分全部都为完成同一个功能而存在，共同完成一个单一的功能，模块已不可再分。即模块仅包括为完成某个功能所必须的所有成分，这些成分紧密联系、缺一不可。

耦合性

非直接耦合：

两个模块之间没有直接关系，他们之间的联系完全是通过主模块的控制和调用来实现的。耦合度最弱，模块独立性最强。

动态规划，无非就是利用历史记录，来避免我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存。下面我们先来讲下做动态规划题很重要的三个步骤，

如果你听不懂，也没关系，下面会有很多例题讲解，估计你就懂了。之所以不配合例题来讲这些步骤，也是为了怕你们脑袋乱了

第一步骤：定义数组元素的含义，上面说了，我们会用一个数组，来保存历史数组，假设用一维数组 dp[] 吧。这个时候有一个非常非常重要的点，就是规定你这个数组元素的含义，例如你的 dp[i] 是代表什么意思？

第二步骤：找出数组元素之间的关系式，我觉得动态规划，还是有一点类似于我们高中学习时的归纳法的，当我们要计算 dp[n] 时，是可以利用 dp[n-1]，dp[n-2]…dp[1]，来推出 dp[n] 的，也就是可以利用历史数据来推出新的元素值，所以我们要找出数组元素之间的关系式，例如 dp[n] = dp[n-1] + dp[n-2]，这个就是他们的关系式了。而这一步，也是最难的一步，后面我会讲几种类型的题来说。