HDU - 2084(动态规划.数塔问题)

题目链接：HDU 2084

题目：

在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的： 

有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？ 
 
已经告诉你了，这是个DP的题目，你能AC吗?

Input

输入数据首先包括一个整数C,表示测试实例的个数，每个测试实例的第一行是一个整数N(1 <= N <= 100)，表示数塔的高度，接下来用N行数字表示数塔，其中第i行有个i个整数，且所有的整数均在区间[0,99]内。 

Output

对于每个测试实例，输出可能得到的最大和，每个实例的输出占一行。 

Sample Input

1
5
7
3 8
8 1 0 
2 7 4 4
4 5 2 6 5

Sample Output

30

思路分析： 

这道题目如果使用贪婪算法不能保证找到真正的最大和。 
在用动态规划考虑数塔问题时可以自顶向下的分析，自底向上的计算。 
从顶点出发时到底向左走还是向右走应取决于是从左走能取到最大值还是从右走能取到最大值，只要左右两道路径上的最大值求出来了才能作出决策。同样的道理下一层的走向又要取决于再下一层上的最大值是否已经求出才能决策。这样一层一层推下去，直到倒数第二层时就非常明了。 
所以第一步对第五层的8个数据，做如下四次决策： 
如果经过第四层2，则在第五层的19和7中肯定是19； 
如果经过第四层18，则在第五层的7和10中肯定是10； 
如果经过第四层9，则在第五层的10和4中肯定是10； 
如果经过第四层5，则在第五层的4和16中肯定是16； 
经过一次决策，问题降了一阶。5层数塔问题转换成4层数塔问题，如此循环决策…… 最后得到1阶的数塔问题。

算法实现：首先利用一个二维数组data存储数塔的原始数据（其实我们只使用数组data一半的空间，一个下三角矩阵），然后利用一个中间数组dp存储每一次决策过程中的结果（也是一个下三角矩阵）。 
初始化dp，将data的最后一层拷贝到dp中。dp[n][j] = data[n][j] (j = 1, 2, …, n) 其中，n为数塔的层数。 
在动态规划过程汇总，我们有dp[i][j] = max(dp[i+1][j], dp[i+1][j+1]) + data[i][j]，最后的结果保存在dp[0][0]中。 
对于上面的数塔，我们的data数组如下：

9
12	15
10	6	8
2	18	9	5
19	7	10	4	16

而我们的dp数组如下：

59
50	49
38	34	29
21	28	19	21
19	7	10	4	16

下面是C++代码的实现（Visual Studio2013通过）：

#include 
#include 

using namespace std;

/************************************************************************/
/* 数塔问题                                                               */
/************************************************************************/
const int N = 50;//为了算法写起来简单，这里定义一个足够大的数用来存储数据(为了避免运算过程中动态申请空间，这样的话算法看起来比较麻烦，这里只是为了算法看起来简单)
int data[N][N];//存储数塔原始数据
int dp[N][N];//存储动态规划过程中的数据
int n;//塔的层数

/*动态规划实现数塔求解*/
void tower_walk()
{
    // dp初始化
    for (int i = 0; i < n; ++i)
    {
        dp[n - 1][i] = data[n - 1][i];
    }
    int temp_max;
    for (int i = n - 1; i >= 0; --i)
    {
        for (int j = 0; j <= i; ++j)
        {
            // 使用递推公式计算dp的值
            temp_max = max(dp[i + 1][j], dp[i + 1][j + 1]);
            dp[i][j] = temp_max + data[i][j];
        }
    }
}

/*打印最终结果*/
void print_result()
{
    cout << "最大路径和：" << dp[0][0] << '\n';
    int node_value;
    // 首先输出塔顶元素
    cout << "最大路径：" << data[0][0];
    int j = 0;
    for (int i = 1; i < n; ++i)
    {
        node_value = dp[i - 1][j] - data[i - 1][j];
        /* 如果node_value == dp[i][j]则说明下一步应该是data[i][j]；如果node_value == dp[i][j + 1]则说明下一步应该是data[i][j + 1]*/
        if (node_value == dp[i][j + 1]) ++j;
        cout << "->" << data[i][j];
    }
    cout << endl;
}

int main()
{
    cout << "输入塔的层数：";
    cin >> n;
    cout << "输入塔的节点数据(第i层有i个节点)：\n";
    for (int i = 0; i < n; ++i)
    {
        for (int j = 0; j <= i; ++j)
        {
            cin >> data[i][j];
        }
    }

    tower_walk();
    print_result();
}

运行结果： 

上面的算法是按照最原始的思路进行书写的，其实还可以进行优化，这里不做详细说明。

题目AC的代码：

#include 
#include 
#include 
#include 
using namespace std;

int main()
{
    int t,n,date[105][105];
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        for(int i=1 ; i<=n ; i++)
            for(int j=1 ; j<=i ; j++)
                scanf("%d",&date[i][j]);
        for(int i=n-1 ; i>0 ; i--)
            for(int j=1 ; j<=i ; j++)
                date[i][j] += max(date[i+1][j] , date[i+1][j+1]);
        printf("%d\n",date[1][1]);
    }
    return 0;
}

---

下面官方的叙述下什么是动态规划： 

动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法——动态规划。动态规划(dynamic programming)是运筹学的一个分支，是求解决策过程(decision process)最优化的数学方法。20世纪50年代初美国数学家R.E.Bellman等人在研究多阶段决策过程(multistep decision process)的优化问题时，提出了著名的最优化原理(principle of optimality)，把多阶段过程转化为一系列单阶段问题，利用各阶段之间的关系，逐个求解，创立了解决这类过程优化问题的新方法——动态规划。（摘自百度百科） 
动态规划处理的对象是针对多阶段决策问题。多阶段决策问题是指这样的一类特殊的活动过程：问题可以分解成若干个相互联系的阶段，在每一个阶段都要做出决策，形成一个决策序列，该决策序列也称为一个策略。每次决策依赖于当前状态，又随即引起状态的转移，决策序列（策略）都是在变化的状态中产生出来的，故有“动态”的含义。所以这种多阶段最优化决策解决问题过程称为动态规划。 
对于每一个决策序列，可以在满足问题的约束条件下用一个数值函数（即目标函数）来衡量该策略的优劣。多阶段决策问题的最优化目标是获取导致问题最优值得最优决策序列，即得到最优解。（摘自《算法设计方法与优化》滕国文等编著）

个人感觉动态规划算法的解决重要的是首先必须有能力将实际问题识别为动态规划问题，然后是找出优化过程中的递推关系式，这样就比较容易了。