dp入门

先一个简单的dp题

HDUOJ2084数塔

Problem Description

在讲述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

从下向上遍历

[cpp]  view plain  copy

1. #include<cstdio>  
2. #include<iostream>  
3. #include<cmath>  
4. #include<algorithm>  
5. #include<cstring>  
6. using namespace std;  
7. int main()  
8. {  
9.     int c;  
10.     int n;  
11.     int a[110][110];  
12.     int dp[110][110];  
13.     cin>>c;  
14.     while(c--)  
15.     {  
16.         memset(dp, 0, sizeof(dp));  
17.         cin>>n;  
18.         for(int i = 1; i <= n; i++)  
19.         {  
20.             for(int j = 1; j <= i; j++)  
21.             {  
22.                 cin>>a[i][j];  
23.             }  
24.         }  
25.         for(int i = n; i >= 1; i--)  
26.         {  
27.             for(int j = 1; j <= i; j++)  
28.             {  
29.                 dp[i][j]=a[i][j] + max(dp[i+1][j],dp[i+1][j+1]);//到i,j这个地方的最优解为它下面连着两个中最大的加上a[i][j]  
30.             }  
31.         }  
32.     cout<<dp[1][1]<<endl;  
33.     }  
34.     return 0;  
35.   
36. }  

然后还可以从上往下遍历相比有那么一点点复杂

[cpp]  view plain  copy

1. #include<cstdio>  
2. #include<iostream>  
3. #include<cmath>  
4. #include<cstring>  
5. using namespace std;  
6. int main()  
7. {  
8.     int c;  
9.     int n;  
10.     int a[110][110];  
11.     int dp[110][110];  
12.     cin>>c;  
13.     while(c--)  
14.     {  
15.         memset(dp, 0, sizeof(dp));  
16.         memset(a, 0, sizeof(a));  
17.         cin>>n;  
18.         for(int i = 1; i <= n; i++)  
19.         {  
20.             for(int j = 1; j <= i; j++)  
21.             {  
22.                 cin>>a[i][j];  
23.             }  
24.         }  
25.         dp[1][1] = a[1][1];  
26.         for(int i = 2; i <= n; i++)  
27.         {  
28.             for(int j = 1; j <= i; j++)  
29.                 dp[i][j]=max(dp[i-1][j], dp[i-1][j-1]) + a[i][j];//到i,j这里的最优解是它向上连着的两个中最大的再加上它自己  
30.         }  
31.         int tmp=0;  
32.         for(int i = 1; i <= n; i++)  
33.         {  
34.             tmp = max(tmp, dp[n][i]);  
35.         }//然后再遍历一遍最后一行找到其中最大的  
36.         cout<<tmp<<endl;  
37.   
38.   
39.     }  
40.   
41. }