dp题目总结（1）——基础

 例题1
数字三角形

题目描述

观察下面的数字金字塔。

写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。

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

在上面的样例中,从7 到 3 到 8 到 7 到 5 的路径产生了最大

输入格式

第一个行包含 R(1<= R<=1000) ,表示行的数目。

后面每行为这个数字金字塔特定行包含的整数。

所有的被供应的整数是非负的且不大于100。

输出格式

单独的一行,包含那个可能得到的最大的和。

样例数据

input

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

output

30

方法一：搜索

路径起点终点明确，走法固定，可以考虑搜索解决。

定义递归函数void  dfs(int x,int y,int curr),表示从（1，1）走到点（x，y）的权值和curr。

当x=n时，到达边界。用所得的curr和ans比较，如果curr比较大，更新ans的值。

如果x

参考程序：
#include
using namespace std;
int a[1010][1010],ans=0;
int n;//输入数塔层数n
void dfs(int x,int y,int curr)
{
    if(x==n)
    {
        if(curr>ans) ans=curr;
        return ;
    }
    dfs(x+1,y,curr+a[x+1][y]);
    dfs(x+1,y+1,curr+a[x+1][y+1]); 
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            cin>>a[i][j];
    dfs(1,1,a[1][1]); 
    cout<     return 0;
}
此方法实际把所有的路径都走了一遍，由于每条路径有n-1步组成，每一步有左下，右下两种选择，路径总数为2n-1   时间复杂度为O(2n-1),

方法二：记忆化搜索

方法一有严重的问题，当n比较大时会花费太多时间，因为它进行了重复的搜索。如一条路径为13-11-12-6-12，另一条为13-11-12-6-7，对于11，12，6这些点进行了重复的搜索。我们完全可以在第一次搜索这些点时，就将这些点到终点的最大权值和记录下来，当我们再次到达这个点，就可以直接调用，不用重复搜索，这种方法就叫记忆化搜索。

因此，我们需要重新定义递归函数dfs。定义dfs（int x，int y）表示（x，y）到终点的最大权值和，最后的答案就是dfs（1，1）.

为了避免重复搜索，我们开设一个数组dg[x][y]表示（x，y）点到终点的最大权值。

参考程序：

#include
using namespace std;
int a[550][550],dg[550][550];
int n;
int dfs(int x,int y)
{
    if(dg[x][y]==-1)//判断是否已经计算过 
    {
        if(x==n)  dg[x][y]=a[x][y];
        else dg[x][y]=max(dfs(x+1,y),dfs(x+1,y+1))+a[x][y];
    }
    return dg[x][y];//计算过直接返回 
}
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
        {
            cin>>a[i][j];
            dg[i][j]=-1;
        }    
    dfs(1,1);
    cout<     return 0;
}

由于每一个点都只计算过一次，且是O（1）的时间，所以这种方法的时间复杂度为O（N*N）(n的平方）

方法三：动态规划（顺推法）

方法二的记忆化搜索，从本质来讲已经算是动态规划了。下面从动态规划的角度分析解题过程。

1.确定状态：

题目求解（1，1）到最底层路径的最大权值，路径起点固定，终点和中间点不确定，因此定义dg[x][y]表示从（1，1）出发到（x，y）路径的最大权值和。最终答案就是寻找最底层的最大值，ans=max{dg[n][1],dg[n][2],dg[n][3]...dg[n][n]}.

2.确定状态转移方程和边界条件

不去考虑（1，1）到（x，y）中间是怎么走的，只需要考虑（x，y）上一步是怎么来的，上一步可能是（x-1，y），也可能是（x-1，y-1），因此dg[x][y]的最大值就是上一步的最大权值和：max{dg[x-1][y],dg[x-1][y-1])，再加上自己的权值a[x][y]。

所以状态转移方程就是：dg[x][y]=max{dg[x-1][y],dg[x-1][y-1]}+a[i][j]。

与递归一样，我们也需要终止条件，防止无限递归下去。我们发现dg[x][y]的值取决于dh[x-1][y],dg[x-1][y-1]，随着递归的深入，最后一定会递归到dg[1][1]，dg[1][1]不能再使用状态转移方程了，所以给dg[1][1]附一个初值，即a[1][1]。

参考程序

#include
using namespace std;
int a[550][550],dg[550][550];
int n;
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=i;j++)
            cin>>a[i][j];
    dg[1][1]=a[1][1];    
    for(int i=2;i<=n;i++)
    {
        for(int j=1;j<=i;j++)
        {
            dg[i][j]=max(dg[i-1][j-1],dg[i-1][j])+a[i][j];
        }
     } 
     int ans=0;
     for(int i=1;i<=n;i++)
         ans=max(ans,dg[n][i]);
    cout<     return 0;
}

这种方法的时间复杂度一样是O（n*n）（n的平方）

方法四：动态规划（逆推）

从根节点，最底层的点出发，向上走，选择它上一层两个方向的最大值为最大的路径，然后从n-1层