动态规划之数字三角形（三种解法：递归，递推，记忆化搜索）

Description

 

如图所示，有一个群岛，共分为若干层，第1层有一个岛屿，第2层有2个岛屿，......，第n层有n个岛屿。每个岛上都有一块宝，其价值是一个正整数（图中圆圈中的整数）。寻宝者只允许从第一层的岛屿进入，从第n层的岛屿退出，不能后退，他能收集他所经过的所有岛屿上的宝贝。但是，从第i层的岛屿进入第i+1层的岛屿时，有且仅有有2条路径。你的任务是：对于给定的群岛和岛上宝贝的价值，计算一个拾宝者行走一趟所能收集宝贝的最大价值。

 

Input

第一行是一个整数n，在[2,20]之间，表示要输入的案例的数量。后面紧跟n个案例。对每个案例，第一行是一个整数mi，在[2, 50]之间，表示该案例中岛屿的层数，后面紧跟mi*(mi+1)/2行，每行有1个整数，表示响应的岛屿上宝贝的价值，每个数值的范围是[1, 1000]。注意：如果mi是4，而后面紧跟的10行的元素分别是5, 2, 1, 4, 7, 9, 4, 2, 3, 5，则表示第一层的数据是5；第2层的数据是2, 1；第3层的数据是4, 7, 9；第4层的数据是4, 2, 3, 5。

Output

对每一个案例，用一行输出一个整数，表示输出拾宝者所能收集宝贝的最大价值。

Sample Input

2
4
5
2
1
4
7
9
2
2
3
5
2
1
2
3

Sample Output

20
4

方法：动态规划。把当前位置（i，j）看成一个状态，设指标函数d（i，j）为从格子（i，j）出发时能得到的最大和，原问题的解为d（1,1）。容易得出状态转移方程d(i,j) = a(i,j) + max{d(i+1,j), d(i+1, j+1)}

方法一：递归计算（时间复杂度O(2^n),会超时）

 1 #include <cstdio>
 2 #include <algorithm>    //for max（val1，val2）
 3 #include <iostream>
 4 using namespace std;
 5 int n;
 6 int a[51][51];
 7 int main()
 8 {
 9     int t;
10     scanf("%d", &t);
11     while (t--)
12     {
13         int i,j;
14         scanf("%d",&n);
15         for(i=1;i<=n;i++)
16         　　for(j=1;j<=i;j++)
17        　　　　 scanf("%d",&a[i][j]);
18         int d(int, int);
19         printf("%d\n", d(1, 1));
20 }
21     system("pause");
22     return 0;
23 }
24 
25 int d(int i, int j)
26 {
27     if (i == n)
28        return a[i][j] + 0;
29     else
30        return a[i][j] + max(d(i+1, j), d(i+1, j+1));
31 }

法2：递推计算（时间复杂度O(n^2),需要辅助数组d）

 1 #include <iostream>
 2 #include <algorithm>                //for max(val1, val2)
 3 #include <cstdio>
 4 using namespace std;
 5 int n;
 6 int a[51][51];
 7 int d[51][51];
 8 int main()
 9 {
10     int t;
11     scanf("%d", &t);
12     while (t--)
13     {
14         int i, j;
15         scanf("%d", &n);
16         for (i = 1; i <= n; ++i)
17             for (j = 1; j <= i; ++j)
18                 scanf("%d", &a[i][j]);
19         for (i = 1; i <= n; ++i)
20             d[n][i] = a[n][i];          //边界处理
21         for (i = n - 1; i >= 1; --i)  //逆序计算
22             for (j = 1; j <= i; ++j)
23                 d[i][j] = a[i][j] + max(d[i+1][j], d[i+1][j+1]);
24         printf("%d\n", d[1][1]);
25     }
26     system("pause");
27     return 0;
28 }

法3：记忆化搜索（递归函数，O(n^2))

 1 #include <iostream>
 2 #include <algorithm>            //for max(val1, val2)
 3 #include <cstdio>
 4 #include <cstring>              //for *memset(s, c, n)   
 5 using namespace std;
 6 int n;
 7 int a[51][51];
 8 int d[51][51];
 9 int main()
10 {
11     int t;
12     scanf("%d", &t);
13     while (t--)
14     {
15         memset(d, -1, sizeof(d));     //初始化数组d为-1 
16         int i, j;
17         scanf("%d", &n);
18         for (i = 1; i <= n; ++i)
19             for (j = 1; j <= i; ++j)
20                 scanf("%d", &a[i][j]);
21         int f(int, int);
22         printf("%d\n", f(1, 1));
23     }
24     system("pause");
25     return 0;
26 }
27 
28 int f(int i, int j)
29 {
30     if (d[i][j] >= 0)     //由于每个数范围为[1,1000]，d[i][j]初始化为-1，可以根据d[i][j] >= 0判断是否已经被计算过
31         return d[i][j];
32     if (i == n)
33         return a[i][j] + 0;
34     else
35         return d[i][j] = a[i][j] + max(f(i+1,j), f(i+1, j+1)); //保存d[i][j]并返回
36 }

本菜花了几个小时整理的，在devc下编译通过。