题目:
在数字三角形中寻找一条从顶部到底边的路径,使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或 右下走。只需要求出这个最大和即可,不必给出具体路径。三角形的行数大于1小于等于100,数字为 0 - 99。
输入格式:
5 //表示三角形的行数 接下来输入三角形 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5
要求输出最大和。
思路分析:
这里的递归和记忆型递归都很容易理解,递归和记忆型递归都是自顶向下,动规则是自底向上,由小规模向上推。
这里写dp方程的时候有一个思路,那就是依赖谁先求谁,这里依赖的是下一步的最大值,于是我们就可以先求出下一步的最大值,然后往上递推求出我们最终需要的值。我们可以用二维数组存储从最后一行开始每个路径的结果。
那有些题目有空间大小的限制,这里就涉及到另一种技巧,滚动数组,滚动数组就是把本身需要保留的结果,但是利用过后直接用下一次的结果给覆盖掉,这样的一个数组就是滚动数组。
滚动数组是DP中的一种编程思想。简单的理解就是让数组滚动起来,每次都使用固定的几个存储空间,来达到压缩,节省存储空间的作用。起到优化空间,主要应用在递推或动态规划中(如01背包问题)。因为DP题目是一个自底向上的扩展过程,我们常常需要用到的是连续的解,前面的解往往可以舍去。所以用滚动数组优化是很有效的。利用滚动数组的话在N很大的情况下可以达到压缩存储的作用。
代码:
import java.time.Duration;
import java.time.Instant;
import java.util.Scanner;
public class 数字三角形 {
public static void main(String[] args) {
// int[][] triangle = {
// {7},
// {3, 8},
// {8, 1, 0},
// {2, 7, 4, 4},
// {4, 5, 2, 6, 5},
// {4, 5, 2, 6, 5, 7},
// {4, 13, 12, 88, 6, 6, 5},
// {3, 8, 7, 11, 9, 22, 66, 3},
// };
// Instant now = Instant.now();
// System.out.println(maxSumUsingRecursive(triangle, 0, 0));
// System.out.println("持续时间为:" +
// Duration.ofMillis(Instant.now().toEpochMilli() -
// now.toEpochMilli()).getSeconds());
//
//
// now = Instant.now();
// System.out.println(maxSumUsingMemory(triangle, 0, 0, new int[8][8]));
// System.out.println("持续时间为:" +
// Duration.ofMillis(Instant.now().toEpochMilli() -
// now.toEpochMilli()).getSeconds());
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[][] triangle = new int[n][];
for (int i = 0; i < n; i++) {
triangle[i] = new int[i + 1];
for (int j = 0; j < i + 1; j++) {
triangle[i][j] = sc.nextInt();
}
}
System.out.println(maxSumUsingDp(triangle, 0, 0));
}
/**
* @param triangle 数字三角形
* @param i 起点行号
* @param j 起点列号
* @return 计算出的最大和
*/
public static int maxSumUsingRecursive(int[][] triangle, int i, int j) {
int rowIndex = triangle.length;
if (i == rowIndex - 1) {
return triangle[i][j];
} else {
// 顶点的值+max(左侧支路的最大值,右侧支路的最大值)
return triangle[i][j]
+ Math.max(maxSumUsingRecursive(triangle, i + 1, j), maxSumUsingRecursive(triangle, i + 1, j + 1));
}
}
/**
* 记忆型递归
*/
public static int maxSumUsingMemory(int[][] triangle, int i, int j, int[][] map) {
int rowIndex = triangle.length;
int value = triangle[i][j];
if (i == rowIndex - 1) {
} else {
// 缓存有值,便不递归
int v1 = map[i + 1][j];
if (v1 == 0) {
v1 = maxSumUsingMemory(triangle, i + 1, j, map);
}
// 缓存有值,便不递归
int v2 = map[i + 1][j + 1];
if (v2 == 0) {
v2 = maxSumUsingMemory(triangle, i + 1, j + 1, map);
}
value = value + Math.max(v1, v2);
}
// 放入缓存
map[i][j] = value;
return value;
}
// 滚动数组
public static int maxSumUsingDp(int[][] triangle, int i, int j) {
int rowCount = triangle.length;// 行数
int columnCount = triangle[rowCount - 1].length;// 最后一行的列数
int[] dp = new int[columnCount];
for (int k = 0; k < columnCount; k++) {
dp[k] = triangle[rowCount - 1][k];// 初始化最后一行
}
for (int k = rowCount - 2; k >= 0; k--) {
for (int l = 0; l <= k; l++) {
dp[l] = triangle[k][l] + Math.max(dp[l], dp[l + 1]);
}
}
return dp[0];
}
}
结果:
路径为:7 3 8 7 5。