数塔问题相关
前言
数塔问题，又称数字三角形、数字金字塔问题，源自于1994年的IOI赛题。数塔问题是多维动态规划问题中一类常见且重要的题型，其变种众多，难度遍布从低到高，掌握该类型题目的算法思维，对于攻克许多多维动态规划的问题有很大帮助。
一、数塔问题原型
1.1 问题描述
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5有一个r行的数塔，数塔上有若干数字。问从数塔的最高点到底部，在所有的路径中，经过的数字的和最大为多少？
如上图，是一个5行的数塔，其中7—3—8—7—5的路径经过数字和最大，为30。
1.2 解法思路
面对数塔问题，使用贪心算法显然是行不通的，比如给的样例，如果使用贪心算法，那选择的路径应当是7—8—1—7—5，其经过数字和只有28，并不是最大。而用深搜DFS很容易算出时间复杂度为
(因为每个数字都有向左下和右下两种选择)，行数一多必定超时。
所以，数塔问题需要使用动态规划算法。
①我们可以从上往下遍历。
可以发现，要想经过一个数字，只能从左上角或右上角的数字往下到达。
所以显然，经过任一数字A时，路径所经过的数字最大和——是这个数字A左上方的数字B以及右上方的数字C两个数字中，所能达到的数字最大和中较大的那一个，再加上该数字A。
故状态转移方程为：
其中i，j表示行数和列数，dp表示储存的最大和，num表示位置上的数字。
表示左上角，
表示右上角。
以样例来说明：在经过第三行的数字1时，我们先看它左上角的数字3和右上角的数字8其能达到的最大和。3显然只有7—3一条路径，故最大和是10；8显然也只有7—8一条路径，其最大和是15；两者中较大的是15，故经过1所能达到的最大和是15+1=16。
这样一步步向下遍历，最后经过每一个位置所能达到的最大和都求出来了，只要从最底下的一行里寻找最大值并输出即可。
②我们也可以从下往上遍历。
一条路径不管是从上往下走还是从下往上走，其经过的数字和都是一样的，所以这题完全可以变成求——从最底层到最高点所经过的最大数字和。
其写法与顺序遍历是一样的，只是状态转移时，变成从该数字的左下角和右下角来取max了。逆序遍历的写法相比于顺序遍历优点在于：少了最后一步求最后一行max的过程，可以直接输出最高点所储存的值。
1.3 代码实现
#include #include using namespace std;//这里以顺序遍历为例int num[1005][1005];//用于储存数塔每个位置的数字int dp[1005][1005];//用于储存经过数塔每个位置所能达到的最大和int main()
{
int r;
scanf("%d",&r);//输入数塔行数 for(int i=1;i<=r;i++)
for(int j=1;j<=i;j++)
scanf("%d",&num[i][j]);
//输入数塔数据，注意i和j要从1开始，防止数组越界 for(int i=1;i<=r;i++)//共计r行 for(int j=1;j<=i;j++)//每行有j个数字 dp[i][j]=max(dp[i-1][j],dp[i-1][j-1])+num[i][j];
//经过该数字的最大和，为左上角和右上角中的max，再加上该数字 int ans=0;
for(int i=1;i<=r;i++)
ans=max(ans,dp[r][i]);//从最后一行中找到最大数 printf("%d\n",ans);//就是答案 return 0;
}二、数塔问题变种
2.1 矩形数塔
以【洛谷P1508：Likecloud-吃、吃、吃】为例。
2.1.1 问题描述有一m行，n列(n为奇数)的数字矩阵(数字中存在部分负数)。
以最后一行的正中间下方为出发点，每次移动可以选择向前方、左前方、右前方移动，问从出发点一直到矩阵的另一侧，所经过的最大数字和为多少。
2.1.2 样例
6 7
16 4 3 12 6 0 3
4 -5 6 7 0 0 2
6 0 -1 -2 3 6 8
5 3 4 0 0 -2 7
-1 7 4 0 7 -5 6
0 -1 3 4 12 4 2
S如上，是一个6行7列的数字矩阵，出发点为最后一行数字4的下方'S'。第一次移动可以选择移动到最后一行3、4、12中一个，若选择移动到4，则第二次移动可以选择移动到倒二行的4、0、7。
该矩阵从出发点移动到矩阵的另一侧，所经过的最大数字和为41。
2.1.3 解题思路
与数塔问题的思路基本一致。
不过该题循环时要从倒二行开始循环到第一行。(最后一行只有三个可到达点，故可初始化后直接跳过)
且状态转移多了一个可选项，状态转移方程如下：
三个状态分别对应下方、左下方和右下方。
另外需要注意：矩阵中存在负数，故dp数组初始化时需要初始化为绝对值较大的负数，防止转移过程中由于访问到矩阵边界外而出现问题。(也可以在矩阵的边界特殊处理)
2.1.4 代码实现
#include using namespace std;
int num[205][205];//储存矩阵int dp[205][205];//储存最大和int main()
{
int m,n;
while(scanf("%d%d",&m,&n)!=EOF)
{
memset(dp,-9999,sizeof(dp));//初始化dp数组为绝对值较大的负数 for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
scanf("%d",&num[i][j]);//输入矩阵 dp[m][n/2+1]=num[m][n/2+1];
dp[m][n/2]=num[m][n/2];
dp[m][n/2+2]=num[m][n/2+2];//初始化最后一行的三个可选择点 for(int i=m-1;i>=1;i--)//从最后一行循环到第一行 for(int j=1;j<=n;j++)
dp[i][j]=max(max(dp[i+1][j+1],dp[i+1][j-1]),dp[i+1][j])+num[i][j];//状态转移 int ans=0;
for(int i=1;i<=n;i++)
if(dp[1][i]>ans) ans=dp[1][i];//dp数组第一行中最大值就是答案 printf("%d\n",ans);
}
return 0;
}2.2 以时间作为一个维度的数塔
以【HDU 1176 免费馅饼】为例。
2.2.1 问题描述有一条10米长的小路，以小路起点为x轴的原点，小路终点为x=10，则共有x=0~10共计11个坐标点。(如下图)
接下来的n行每行有两个整数x、T，表示一个馅饼将在第T秒掉落在坐标x上。
同一秒在同一点上可能掉落有多个馅饼。
初始时你站在x=5上，每秒可移动1m，最多可接到所在位置1m范围内某一点上的馅饼。
比如你站在x=5上，就可以接到x=4、5、6其中一点上的所有馅饼。
问你最多可接到多少个馅饼。
2.2.2 样例6 (表示有6个馅饼)
5 1(在第1s，有一个馅饼掉落在x=5上)
4 1(在第1s，有一个馅饼掉落在x=4上)
6 1
7 2(在第2s，有一个馅饼掉落在x=7上)
7 2(同1s可能有多个馅饼掉落在同一点上)
8 3
样例中最多可接到4个馅饼。
其中一种接法是：第1s接住x=5的一个馅饼，第2s移动到x=6，接住x=7上的两个馅饼，第3s移动到x=7，接住x=8的一个馅饼，共计4个馅饼。
2.2.3 解题思路
本质上还是数塔问题，不过此时“行数”这一维度变成了“时间”。
以样例来说明：可以理解为在第一行的4、5、6三列的数字为1，第二行的第7列数字为2，第8列数字为1。然后出发点在第0行的第5列。每次移动可选择往下，左下，右下三种方式。
所以解法基本一致，解题时注意题目的附加条件即可。
2.2.4 代码实现
#include #include #include using namespace std;
int dp[100005][15];//列数只有11列，行数则是时间int main()
{
int n;
while(scanf("%d",&n)!=EOF&&n)
{
int maxn=0;
memset(dp,0,sizeof(dp));
for(int i=1;i<=n;i++)
{
int x,y;
scanf("%d%d",&x,&y);//y是时间，x是坐标 dp[y][x+1]++;//第y行的第x+1列(因为有x=0)馅饼数+1 if(y>maxn) maxn=y;
}
for(int i=maxn-1;i>=0;i--)//这里采用倒序处理，节省最后一步 {
for(int j=1;j<=11;j++)
{
dp[i][j]=dp[i][j]+max(max(dp[i+1][j],dp[i+1][j+1]),dp[i+1][j-1]);
}
}
printf("%d\n",dp[0][6]);//由于是倒序处理，直接输出出发点的数据即可 }
return 0;
}2.3双线程取数(四维DP)
2.3.1 例1：【洛谷P1004：方格取数】
2.3.1.1 问题描述有一个N×N的方格图，在某些方格内放入正整数，其他方格则放入0。
某人从方格图左上角出发，只能选择向下或向右行走，直到走到右下角，过程中他可以取走方格内的数(取完后变成0)。这样连续走两次，问取出的数的和最大是多少？
2.3.1.2 样例
A
0 0 0 0 0 0 0 0
0 0 13 0 0 6 0 0
0 0 0 0 7 0 0 0
0 0 0 14 0 0 0 0
0 21 0 0 0 4 0 0
0 0 15 0 0 0 0 0
0 14 0 0 0 0 0 0
0 0 0 0 0 0 0 0
B
如上，这是一个8×8的方格图，第一次走，取走13、14、4，第二次走，取走21、15，最大和为67。
注：方格内的数是按照a b c的格式给的，a代表行数，b代表列数，c代表值。
如2 3 13代表第二行第三列的值是13。
2.3.1.3 解题思路
如果只是单线程，也就是只走一次，那这题就和矩形数塔没什么差别，建立二维数组
用于储存走到(i,j)时的最大和即可。
但这题是双线程，所以我们需要建立四维数组
用于储存第一次走到(i,j)，第二次走到(k,l)时，所取得的最大和。
根据题意，行走时只能往下或往右走，所以此时就存在四种情况来到达(i,j)和(k,l)：
第一次走往下走，第二次走往下走；——(i-1,j)、(k-1,l)
第一次走往下走，第二次走往右走；——(i-1,j)、(k,l-1)
第一次走往右走，第二次走往下走；——(i,j-1)、(k-1,l)
第一次走往右走，第二次走往右走；——(i,j-1)、(k,l-1)
也就是说：当前状态可能来源于四种之前的状态的转移
所以，状态转移方程如下：
但还需要注意！根据题意，在第一次走时取走的数会变成0，则第二次走如果还经过相同的地方，那就只能取到0了，所以这里还需要特判：
if(i==k&&j==l) dp[i][j][k][l]-=num[i][j];上面代码的意思是，当两次走到同一个位置时，只能取走一次方格内的值，由于状态转移方程里取了两次，所以这里特判时需要减去一次。
2.3.1.4 代码实现
#include #include #include using namespace std;
int num[10][10];
int dp[10][10][10][10];
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
memset(dp,0,sizeof(dp));
while(1)
{
int a,b,c;
scanf("%d%d%d",&a,&b,&c);
if(a==0) break;
num[a][b]=c;
}//输入方格内的数 for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
for(int k=1;k<=n;k++)
for(int l=1;l<=n;l++)
{
dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i][j-1][k][l-1]),max(dp[i-1][j][k][l-1],dp[i][j-1][k-1][l]))+num[i][j]+num[q][p];//状态转移 if(i==k&&j==l) dp[i][j][q][p]-=num[i][j];//走到同一点时特判 }
printf("%d\n",dp[n][n][n][n]);//两次终点都是右下角 }
return 0;
}2.3.2 例2：【洛谷P1006：传纸条】
2.3.2.1 问题描述有一m行n列的数字矩阵，寻找两条不重复的路径从左上角到达右下角，求两次取的数的和的最大值。
注：本题相比例1多了一个要求——两次走的路径不可重复，也就是
注2：起点和终点储存的值都是0。
2.3.2.2 解题思路
具体思路与上一例基本相似，只是由于多出的要求使得路径不可重复，所以不能再向上面那题一样去特判，而是在循环过程中就不能让路径重复。
这里的办法就是写for语句时让l从j+1开始循环。
为什么这样可以避免路径重复？
因为在循环过程中，l永远没法等于j，也就是走的时候不可能走到同一个坐标上，那就满足了题意。
2.3.2.3 代码实现
#include #include #include using namespace std;
int num[60][60];
int dp[60][60][60][60];
int main()
{
int m,n;
while(scanf("%d%d",&m,&n)!=EOF)
{
memset(dp,0,sizeof(dp));
for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
scanf("%d",&num[i][j]);//输入矩阵 for(int i=1;i<=m;i++)
for(int j=1;j<=n;j++)
for(int k=1;k<=m;k++)
for(int l=j+1;l<=n;l++)//让l从j+1开始 {
dp[i][j][k][l]=max(max(dp[i-1][j][k-1][l],dp[i][j-1][k][l-1]),max(dp[i-1][j][k][l-1],dp[i][j-1][k-1][l]))+num[i][j]+num[k][l];
}//由于坐标不会重复，无需再特判 printf("%d\n",dp[m][n-1][m-1][n]);//需要注意此时输出的答案是在哪里的值 //因为终点和起点储存的值都是0，所以才能这样，否则还需要加上一次终点的值 }
return 0;
}2.3.3 四维降三维的空间优化
在上面的两个例子中，由于开了四维数组，空间复杂度过于大了，一旦给的行列数稍大，就可能超出限定的内存，所以此时需要进一步地优化来降低空间复杂度。
四维降三维的思想如下：
我们可以发现，由于走的过程中只允许向右或向下走，所以每走一步不是行数加一就是列数加一。
故在两条路径的长度一样时(也就是走的步数一样多时)
所以，我们可以开一个三维的数组
其中第一维代表步数，m行n列的矩阵步数从0~n+m-2。
第二维和第三维分别表示两条路径的横坐标，只要知道了步数和横坐标，就可以通过计算得出纵坐标。
这样，空间复杂度就下降了。
代码实现读者可以自行尝试。
2.3.4 二维的空间优化
注：在看本步优化前，建议先学习背包问题一节。
在解决背包问题时，我们采用了滚动数组的方法使数组从二维降到了一维，这是因为背包问题中，我们只用得到上一“行”的数据。
同样的，本题中，由于只能向右或向下走，状态的转移也只用得到上一行和上一列(也就是上一步)的数据，故也可以使用滚动数组降维至二维。
2.3.4.1 代码实现
#include#includeusing namespace std;
int dp[200][200];
int num[200][200];
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
scanf("%d",&num[i][j]);
for(int k=1;k<=n+m-2;k++)//步数，通过滚动数组降去了这一维 for(int i=n;i>=1;i--)//滚动数组需要倒序处理！！！ for(int p=n;p>i;p--)//p>i是为了防止路径重复 {
dp[i][p]=max(max(dp[i][p],dp[i-1][p-1]),max(dp[i-1][p],dp[i][p-1]));
dp[i][p]+=num[i][k-i]+num[p][k-p];
}
printf("%d\n",dp[n-1][n]);
return 0;
}
