蓝桥杯 试题 历届试题 数字三角形【第十一届】【省赛】【C组】

 

首先本题我想出了两种解法，一种是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所以就可以统一代码）