各类经典dp问题分讲（HDU 2084、HDU 1003、HDU 1176）

总括

动态规划基本步骤： 找出 阶段 状态 决策

考虑如何把整个问题拆成几个子问题

然后考虑一个状态能由什么推出 如何决策能够得到该阶段的最优解

递归是自顶向下的分解 动态规划就是自底向上的递推。把递归的每个状态表示出来 再按照动态规划的顺序推 自然就能看出联系

例题分析

HUD 2084

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

分析

dp入门的数塔问题从上往下分析问题，从倒数第二行开始看。将倒数第二行的每一个数改为当前的路径所允许的最大值（如上图中左下角的第二行第一个应该改为21 ： 19 + 2； 以此类推）最终a[1][1]即为所求值

核心代码：

for(i = 1; i <= n; i++)
{
for(j = 1; j <= i; j++)
{
if(a[i + 1][j] > a[i + 1][j + 1])
a[i][j] += a[i + 1][j];
else
a[i][j] += a[i + 1][j + 1];
}
}

贴代码

#include <iostream>
#define MAX 20
using namespace std;
int main()
{
cout << "Please input N(lines)" << endl;
int n;
cin >> n;
int a[MAX + 1][MAX + 1][3]; //[0]用来存数，[1]参与运算，[2]表示向左(0)，还是向右(1)
//输入数塔
for (int i = 1; i <= n; ++i)
{
cout << "Please input line " << i << endl;
for (int j = 1; j <= i; ++j) //第i行有i个数
{
cin >> a[i][j][0];
a[i][j][1] = a[i][j][0];
a[i][j][2] = 0;
}
}
cout << endl;
//计算
for (int i = n - 1; i >= 1; --i) //从倒数第二行开始
{
for (int j = 1; j <= i; j++)
{
if (a[i + 1][j][1] > a[i + 1][j + 1][1]) //左边大
{
a[i][j][2] = 0; //选择左边
a[i][j][1] += a[i + 1][j][1];
}
else //右边大
{
a[i][j][2] = 1; //选择右边
a[i][j][1] += a[i + 1][j + 1][1];
}
}
}
//输出数塔
for (int i = 1; i <= n; ++i)
{
for (int j = 1; j <= i; ++j)
{
cout << a[i][j][0] << " ";
}
cout << endl;
}
//输出最大值
cout << a[1][1][1] << endl;
//输出路径
for (int i = 1, j = 1; i <= n; ++i)
{
cout << "[" << i << "," << j << "]" << " -> ";
j += a[i][j][2];
}
cout << endl;
return 0;

HDU 1003

a[1],a[2],a[3]……a
, your job is to calculate the max sum of a

sub-sequence. For example, given (6,-1,5,4,-7), the max sum in this

sequence is 6 + (-1) + 5 + 4 = 14.

Input The first line of the input contains an integer T(1<=T<=20) which means the number of test cases. Then T lines follow, each line

starts with a number N(1<=N<=100000), then N integers followed(all the

integers are between -1000 and 1000).

Output For each test case, you should output two lines. The first line is “Case #:”, # means the number of the test case. The second

line contains three integers, the Max Sum in the sequence, the start

position of the sub-sequence, the end position of the sub-sequence. If

there are more than one result, output the first one. Output a blank

line between two cases.

Sample Input

2 5 6 -1 5 4 -7 7 0 6 -1 1 -6 7 -5
Sample Output

Case 1: 14 1 4
Case 2: 7 1 6

分析

动态规划的另一个经典例题

和上文的数塔的方法基本一样：化简为2层 然后层层折叠 每次处理2层 （2层不会有路径选择的问题）

与上文不同的是 在求最大的子序列和的时候如果前N项的和为负数那么直接忽略 因为 a + 负数 < a

核心代码

t = 0;
sta = end = k = 1;
for (i = 1; i <= n; i++)
{
scanf("%d", &a);

t += a;
if (t > max)
{                //另外要注意的一点是 用sta和end来纪录数组的开始和结束位置
max = t;
sta = k;
end = i;
}//只有当 t > max的时候才能对 sta 和 end 进行覆盖操作
if (t < 0)
{
t = 0;
k = i + 1;
}
}

全部代码

#include <stdio.h>
int main()
{
int n, T, a, sta, end, max, k, i, p, t;

scanf("%d", &T);
for (p = 1; p <= T; p++) {
scanf("%d", &n);
max = -9999;     //因为一个数a 是-1000~1000的，所以这里相当于变成最小值
t = 0;           //表示 某段连续和
sta = end = k = 1;   // sta最大和的开始,end最大和的结束,k记录每次求和的开始
for (i = 1; i <= n; i++)
{
scanf("%d", &a);

t += a;
if (t > max)
{   //记录最大连续和的值
max = t;
sta = k;
end = i;
}
if (t < 0)
{
t = 0;
k = i + 1;
}
}

if (p != 1) printf("/n");
printf("Case %d:/n", p);
printf("%d %d %d/n", max, sta, end);
}
}

HUD1176

题目

免费馅饼

Problem Description

都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下身上的背包去接。但由于小径两侧都不能站人，所以他只能在小径上接。由于gameboy平时老呆在房间里玩游戏，虽然在游戏中是个身手敏捷的高手，但在现实中运动神经特别迟钝，每秒种只有在移动不超过一米的范围内接住坠落的馅饼。现在给这条小径如图标上坐标：

为了使问题简化，假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时gameboy站在5这个位置，因此在第一秒，他只能接到4,5,6这三个位置中其中一个位置上的馅饼。问gameboy最多可能接到多少个馅饼？（假设他的背包可以容纳无穷多个馅饼）

Input

输入数据有多组。每组数据的第一行为以正整数n(0 < n < 100000)，表示有n个馅饼掉在这条小径上。在结下来的n行中，每行有两个整数x,T(0 < T < 100000),表示在第T秒有一个馅饼掉在x点上。同一秒钟在同一点上可能掉下多个馅饼。n=0时输入结束。

Output 每一组输入数据对应一行输出。输出一个整数m，表示gameboy最多可能接到m个馅饼。

提示：本题的输入数据量比较大，建议用scanf读入，用cin可能会超时。

Sample Input

6

5 1

4 1

6 1

7 2

7 2

8 3

0

Sample Output

4

分析

在位置i中在J秒回落下n个馅饼， 依旧是动态规划问题 倒叙求和（貌似动态规划问题都是倒序）

关于位置有3大种可能性 0； 10； 1-9 （因为0 和 10 只有1种走动的方向）

首先用数组dp[i][j]读入掉落馅饼的时间和位置 然后用DP进行累加

动态规划的核心就是

从最末尾的情况开始通过MAX求得有限个不同路径的最优化的一个 然后向前递归 最终输出题目所要求的初始位置。

核心代码

time = max(m);// input的读入是n, m； m的最大值表示时间的掉落馅饼的最大持续时间
for(i = time - 1; i >= 0; i--)
{
dp[0][i] = max2(dp[0][i + 1], dp[1][i + 1]);
dp[10][i] = max2(dp[10][i + 1], dp[9][i + 1]);
for(j = 1; j <= 9; j++)
{
dp[j][i] = max(dp[j - 1][i + 1], dp[j][i + 1], dp[j + 1][i + 1]);
}
}

全部代码

#include<iostream>
#include<algorithm>
using namespace std;
int dp[11][100001];
int max(int a,int b,int c=-1)
{
if(a<b) a=b;
if(a<c) a=c;
return a;
}
int main()
{
int n,i,j;
int t,x;
while(scanf("%d",&n)!=EOF &&n)
{
memset(dp,0,sizeof(dp));
int maxtime=0;
for(i=0;i<n;i++)
{
scanf("%d%d",&x,&t);
++dp[x][t];
maxtime=t>maxtime?t:maxtime;
}
for(j=maxtime-1;j>=0;--j)
{
dp[0][j]+=max(dp[0][j+1],dp[1][j+1]);
dp[10][j]+=max(dp[10][j+1],dp[9][j+1]);
for(i=1;i<10;i++)
{
dp[i][j]+=max(dp[i][j+1],dp[i+1][j+1],dp[i-1][j+1]);
}
}
printf("%d\n",dp[5][0]);
}
return 0;
}

全文总结

为了便于分析先分一下类（题数太少不好分 慢慢补充 - - ）

规定起始位置

如第一题和第三题 我们都可以用一个二维平面来表示题目中input所给予的变量

而且这个二维平面的入口是确定的

出口位于一条一维直线上

我们所要选择的就是点和线之间的路径问题

对此可以通过

从倒数第二行开始求最优解而一步步递推到最初始的一行，进而输出初始位置的点

未规定起始位置而求最优

如第二题从两端的位置开始 重点寻找规划问题的跳出（或者说否定）方案然后执行