首先本题我想出了两种解法,一种是dfs,一种是利用数组存储已知信息来减少时间复杂度,网上还有另外一种dp的方法,dp实际也是利用数组和递推关系来减少时间复杂度,所以第二种方法我们就叫做类dp吧(此时我对dp掌握的还不太好,后续可能会补上用dp的做法)
一、dfs 对了一般的用例 其他的超时了
dfs没有什么好说的,就是遍历所有可能的路径,最后取最大值。
a[N][N]存储三角阵,n代表矩阵的行数,我们就定义cons代表能够向左/右走的最大步数, cons = n/2。比如一共5行,就最多走四步,那么只有一种可能就是向左2步向右两步。一共6行,就最多五步,那么就有两种可能2+3 、3+2。(这里就可以看出行数的奇偶不同可能需要分开讨论)
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int n;
int a[N][N]; //存储矩阵
int cons; //最多向左或者向右走的次数
int Add(int res, int i, int j, int left, int right)
{
// printf("left:%d right:%d res:%d\n", left, right, res);
int m = res;
int n = res;
if(left < cons)
{
m += a[i + 1][j];
left ++;
if(left + right < n- 1) m = max(m, Add(m, i + 1, j, left, right));
left --;
}
if(right < cons)
{
n += a[i + 1][j + 1];
right ++;
if(left + right < n - 1) n = max(n, Add(n, i + 1, j + 1, left, right));
right --;
}
res = max(m, n);
return res; //res代表最终答案 是不能在多种可能的情况重复自增的
}
int main()
{
// freopen("in.txt","r", stdin);
cin >> n;
cons = n / 2;
for(int i = 1; i <= n; i ++)
{
for(int j = 1; j <= i; j ++) scanf("%d", &a[i][j]);
}
// for(int i = 1; i <= n; i ++)
// {
// for(int j = 1; j <= i; j ++) printf("%d", a[i][j]);
// puts(" ");
// }
int res = Add(a[1][1], 1, 1, 0, 0);
printf("%d", res);
return 0;
}
递归是一种从上到下的思维,Add函数返回从i,j位置走到最后取得的最大的和。
所以dfs里面一共就有两种情况,分别是向左走,或者向右走,注意只有向左/右的步数小于cons才能有这个选择,最后res就是两者的最大值。
还有注意dfs需要回溯,我的代码结构是上下的,但是向左和向右两种情况本身是平行的,所以向左走带来的影响比如left的变化,一定要在递归后取消掉,负责会对下面向右走的情况产生影响。
超时分析:dfs遍历了所有可能的路径,但是我们会发现很多路径是重复交叉的,比如所有的路径最终都指向一个终点,那么也就代表有许多路径在中途也会是重复的,一个位置可以被多个路径到达,那为什么我们不只取当前位置能达到的最大结果,然后在之后的选择种只用这个最大的结构。
二、类dp 通过全部用例
用数组b[N][N]存储当前位置能够达到的最大和
我们以行为单位来看待这个问题,当我们需要从第i行的某一个数到第i+1行的某一个数时,其实到第i行的这个数一共有很多条路径,也就有很多值,但是我们并不需要这么多,我们只要知道最大的那个结果时多少就ok了,用这个最大的结果加上下一行的这个数,就是其能够达到的最大和的一种。
为什么时一种能,因为到达i,j这个点一共可以有左上和右上两种情况,当左上/右上的点已经找到其最大值时,只需要b[i][j] = max(b[i - 1][j] + a[i][j], b[i - 1][j - 1] + a[i][j])就可以找到到达i,j的最大值。
这个方法成立的原因时,第一行只有一个数,而此时b[1][1]是确定的,所以一定可以递推到最终结果的最大值。
关于路径的特点,奇数行时所有路径经过的点可以组成菱形,偶数行时所有路径经过的点可以组成两个菱形。
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 110;
int a[N][N];
int b[N][N];
int n;
int res;
int cons;
int main()
{
freopen("in.txt","r", stdin);
cin >> n;
cons = n / 2;
for(int i = 1; i <= n; i ++)
{
for(int j = 1; j <= i; j ++) scanf("%d", &a[i][j]);
}
// for(int i = 1; i <= n; i ++)
// {
// for(int j = 1; j <= i; j ++) printf("%d", a[i][j]);
// puts(" ");
// }
b[1][1] = a[1][1];
if(n % 2 == 1)
{
for(int i = 2; i <= cons + 1; i ++)
{
for(int j = 1; j <= i; j ++)
{
b[i][j] = max(b[i - 1][j] + a[i][j], b[i - 1][j - 1] + a[i][j]);
}
}
for(int i = cons + 2; i <= n; i++)
{
for(int j = i - cons; j <= cons + 1; j ++)
{
b[i][j] = max(b[i - 1][j] + a[i][j], b[i - 1][j - 1] + a[i][j]);
}
}
res = b[n][cons + 1];
}
else
{
for(int i = 2; i <= cons; i ++)
{
for(int j = 1; j <= i; j ++)
{
b[i][j] = max(b[i - 1][j] + a[i][j], b[i - 1][j - 1] + a[i][j]);
}
}
for(int i = cons + 1; i <= n; i++)
{
for(int j = i - cons; j <= cons; j ++)
{
b[i][j] = max(b[i - 1][j] + a[i][j], b[i - 1][j - 1] + a[i][j]);
}
}
for(int i = cons + 1; i <= n; i++)
{
for(int j = i - cons + 1; j <= cons + 1; j ++)
{
b[i][j] = max(b[i - 1][j] + a[i][j], b[i - 1][j - 1] + a[i][j]);
}
}
res = max(b[n][cons], b[n][cons + 1]);
}
for(int i = 1; i <= n; i ++)
{
for(int j = 1; j <= n; j ++) printf("%5d", b[i][j]);
puts(" ");
}
printf("%d", res);
return 0;
}
注意:关于边界的讨论,如果矩阵种的计算,需要涉及到向左上/右上取数,最好从a[1][1]开始存数,这样利用0索引中的0可以减少很多边界讨论使得代码更加简洁。(相加就让无用的为0 相乘就让无用的为1)
(比如本题三角形边上的其实只有一种情况,但是由于上层为0所以就可以统一代码)