动态规划（DP）之入门学习-数字三角形

来源：互联网发布：驱动中国双十一数据编辑：程序博客网时间：2024/05/29 03:46

原文地址：http://blog.csdn.net/zwhlxl/article/details/46225947

数字三角形案例

题目描述 Description

下图给出了一个数字三角形，请编写一个程序，计算从顶至底的某处的一条路径，使该路径所经过的数字的总和最大。
（1）每一步可沿左斜线向下或右斜线向下
（2）1 < 三角形行数 < 100
（3）三角形数字为0，1，…99
这里写图片描述

输入描述 Input Description

有很多个测试案例，对于每一个测试案例，通过键盘逐行输入，第1行是输入整数（如果该整数是0,就表示结束，不需要再处理），表示三角形行数n，然后是n行数

输出描述 Output Description

输出最大值。

样例输入 Sample Input

573 88 1 02 7 4 44 5 2 6 51
2
3
4
5
6

样例输出 Sample Output

递归解法

解题思路

用二维数组存放数字三角形。
D( r, j) : 第r行第 j 个数字(r,j从1 开始算)
MaxSum(r, j) : 从D(r,j)到底边的各条路径中，最佳路径的数字之和。
问题：求 MaxSum(1,1)
典型的递归问题。
D(r, j)出发，下一步只能走D(r+1,j)或者D(r+1, j+1)。故对于N行的三角形：

if ( r == N) MaxSum(r,j) = D(r,j)else MaxSum( r, j) = Max{ MaxSum(r＋1,j), MaxSum(r+1,j+1) } + D(r,j)1
2
3
4

代码实现

#include <iostream>#include <algorithm>#define Max 101using namespace std;int D[Max][Max];int num;int MaxSum(int i, int j){    if(i == num)        return D[i][j];    int x = MaxSum(i + 1, j);    int y = MaxSum(i + 1, j + 1);    return max(x,y) + D[i][j];}int main(int argc, char const *argv[]){    int i, j;    cin >> num;    for(i = 1; i <= num; i ++)        for(j = 1; j <= i; j ++)            cin >> D[i][j];    cout << MaxSum(1,1) << endl;    return 0;}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

时间复杂度

递归求解，会严重超时，因为出现重复计算，如下图所示。深度遍历每条路径，存在大量重复计算。5行的总时间为：1+2+4+8+16=31=25−1则时间复杂度为 2n
这里写图片描述

记忆递归动归程序

解题思路

第一次计算MaxSum(r,j)值的时候，保存下来，下次需要的时候，直接取出计算，这样就避免了重复计算。时间复杂度为O(n2)，因为三角形的数字总和为n(n+1)/2。

代码实现

#include <iostream>#include <algorithm>#include "string.h"#define Max 101using namespace std;int D[Max][Max];int Max_Sum_arr[Max][Max];int num;int MaxSum(int i, int j){    if(Max_Sum_arr[i][j] != -1)        return Max_Sum_arr[i][j];    if(i == num)        Max_Sum_arr[i][j] = D[i][j];    else{        int x = MaxSum(i + 1, j);        int y = MaxSum(i + 1, j + 1);        Max_Sum_arr[i][j] = max(x,y) + D[i][j];    }    return Max_Sum_arr[i][j];}int main(int argc, char const *argv[]){    int i, j;    cin >> num;    for(i = 1; i <= num; i ++)        for(j = 1; j <= i; j ++)            cin >> D[i][j];    memset(Max_Sum_arr,-1,sizeof(Max_Sum_arr));    cout << MaxSum(1,1) << endl;    return 0;}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

递推型动归程序

解题思路

从底向上递推，出最后一行外，每一行的每个点的最大值等于自身加上下面一行对应左右两个点的最大值，从下往上递推，最顶部的即所求。比如下图所示。首先最后一行的最大值就是它本身。倒数第二行第一个数7就是输入的倒二行的第一个数2 + 4 和 2 +5 取最大值。逐步递推到顶部。

573 88 1 02 7 4 44 5 2 6 51
2
3
4
5
6

这里写图片描述

代码实现

#include <iostream>#include <algorithm>#include "string.h"#define Max 101using namespace std;int D[Max][Max];int num;int MaxSum(int num){    int i, j;    for(i = num - 1; i >= 1; i --)        for(j = 1; j <= i; j ++){            D[i][j] = max(D[i+1][j],D[i+1][j+1]) + D[i][j];        }    return D[1][1];}int main(int argc, char const *argv[]){    int i, j;    cin >> num;    for(i = 1; i <= num; i ++)        for(j = 1; j <= i; j ++)            cin >> D[i][j];    cout << MaxSum(num) << endl;    return 0;}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

动规解题的一般思路

1、将原问题分解为子问题

把原问题分解为若干个子问题，子问题和原问题形式相同或类似，只不过规模变小了。子问题都解决，原问题即解决(数字三角形例）
子问题的解一旦求出就会被保存，所以每个子问题只需求解一次。

2、确定状态

在用动态规划解题时，我们往往将和子问题相关的各个变量的一组取值，称之为一个“状态”。一个“状态”对应于一个或多个子问题，所谓某个“状态”下的“值”，就是这个“状态”所对应的子问题的解。

3、确定一些初始状态（边界状态）的值

以“数字三角形”为例，初始状态就是底边数字，值就是底边数字值。

4、确定状态转移方程

定义出什么是“状态”，以及在该 “状态”下的“值”后，就要找出不同的状态之间如何迁移――即如何从一个或多个“值”已知的“状态”，求出另一个“状态”的“值” 。状态的迁移可以用递推公式表示，此递推公式也可被称作“状态转移方程”。

能用动规解决的问题的特点

问题具有最优子结构性质。如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质。
无后效性。当前的若干个状态值一旦确定，则此后过程的演变就只和这若干个状态的值有关，和之前是采取哪种手段或经过哪条路径演变到当前的这若干个状态，没有关系。

参考资料

《程序设计导引及在线实践》——北京大学信息科学技术学院

阅读全文

0 0