P1216 [USACO1.5] [IOI1994]数字三角形 Number Triangles

P1216 [USACO1.5] [IOI1994]数字三角形 Number Triangles

题目描述

观察下面的数字金字塔。

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

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

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

输入格式

第一个行一个正整数 r ,表示行的数目。

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

输出格式

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

输入输出样例

输入 #1

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

输出 #1

30

说明/提示

【数据范围】
对于 100% 的数据，1≤r≤1000，所有输入在 [0,100] 范围内。

题目翻译来自NOCOW。

USACO Training Section 1.5

IOI1994 Day1T1

递归分析（只有函数）：

int a[100][100];
void tri(int x,int y,int len)
{
    if(x==n)
    {
        if(Max<len)
            Max=len;
        return;
    }
    tri(x+1,y,len+a[x+1][y]);
    tri(x+1,y+1,len+a[x+1][y+1]);
}

问题是存在重复子问题

还是分析一下问题：

1.分析问题状态：

​ $f[x][y]$表示从（1，1）到（x，y）的最大路径长度

2.分解子问题

​ $f[x][y]=max(f[x-1][y-1],f[x-1][y])+a[x][y]$;

3.初始化状态数组金额边界状态

​ 1）初始化状态数组f为极小值-0x33f3f3f

​ 2）初始化边界状态$f[1][1]$为$a[1][1]$

4.思考计算顺序

​ 从上到下，从左到右

5.获得最终答案

​ $ans=max(f[n][k])$； $k\in [1,n]$

按照这个思路，写出代码：

#include<bits/stdc++.h>
using namespace std;

int a[1000][1000];
int f[1000][1000];

int main()
{	
    //初始化边界数组
	memset(f,-0x3f,sizeof(f));
	int r;
	cin>>r;
	for(int i=1;i<=r;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
		}
	}
	f[1][1]=a[1][1];//初始化边界状态
    //递推，从第二层开始
	for(int i=2;i<=r;i++)
	{
		for(int j=1;j<=i;j++)
		{
			f[i][j]=max(f[i-1][j-1],f[i-1][j])+a[i][j];
		}
	}
    //求最终答案
	int Max=-0x3f;
	for(int i=1;i<=r;i++)
	{
		if(f[r][i]>Max)	Max=f[r][i];
	}
	cout<<Max;
	return 0;
}

千万不要忘了，$f[i][j]$赋值后面要加上那个点本身的数字$a[i][j]$

但是，我又犯了一个致命的错误

我定义a和f数组的时候只定义了$a[1000][1000]和f[1000][1000]$

【数据范围】
对于 100% 的数据，1≤r≤1000，所有输入在 [0,100] 范围内。

看到了吧，数组定义时应该多定义一点，至少为$a[1001][1001]和f[1001][1001]$

最终版代码（DP）

#include<bits/stdc++.h>
using namespace std;

int a[1005][1005];
int f[1005][1005];

int main()
{	
	memset(f,-0x3f,sizeof(f));
	int r;
	cin>>r;
	for(int i=1;i<=r;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
		}
	}
	f[1][1]=a[1][1];
	for(int i=2;i<=r;i++)
	{
		for(int j=1;j<=i;j++)
		{
			f[i][j]=max(f[i-1][j-1],f[i-1][j])+a[i][j];
		}
	}
	int Max=-0x3f;
	for(int i=1;i<=r;i++)
	{
		if(f[r][i]>Max)	Max=f[r][i];
	}
	cout<<Max;
	return 0;
}

进阶（逆向思维）

可以正着推，那么也就可以逆着推，试着从最后一排开始，往前直到第一排进行计算

也不难，一会就写出来了

#include<bits/stdc++.h>
using namespace std;

int a[1005][1005];
int f[1005][1005];

int main()
{	
	memset(f,-0x3f,sizeof(f));//初始化边界数组
	int r;
	cin>>r;
	for(int i=1;i<=r;i++)
	{
		for(int j=1;j<=i;j++)
		{
			cin>>a[i][j];
		}
	}
	for(int i=1;i<=r;i++)
	{
		f[r][i]=a[r][i];//初始化边界状态
	}
    //递推，从倒数第二层开始
	for(int i=r-1;i>=1;i--)
	{
		for(int j=1;j<=i;j++)
		{
			f[i][j]=max(f[i+1][j],f[i+1][j+1])+a[i][j];
		}
	}
    //输出最终答案
	cout<<f[1][1];
	return 0;
}

以上就是本道题的题解和我的思路全过程