【java】数字三角形最长路径

有一个由非负整数组成的三角形，第一行只有一个数，除了最下行之外每个数字的左下方和右下方各有一个数，如下图所示：

每个结点的值代表它的权值，从第一行开始，每次可以往左下或右下走一格，直到走到最下行，把沿途经过的数全部加起来，如何走才能使得这个和尽量大。

输入n代表三角形行数，然后输入每行各个结点的权值，

样例输入：

4

1

3 2

4 10 1

4 3 2 20

样例输出：

24

思路：用二维数组保存三角形，a[i][j]代表(i,j)的权值，然后定义指标函数d(i,j)为从结点(i,j)出发时能得到的最大和。

可以得到状态转移方程：d(i,j)=a(i,j)+max[d(i+1,j),d(i+1,j+1)]

最优子结构：全局最优解包含局部最优解；动态规划的核心是状态和状态转移方程。

根据状态转移方程，可设计出算法：

方法一  递归计算

import java.util.Scanner;

public class Main {
	public static int dpSolution(int[][] a,int i,int j){
		if(i>=a.length)
			return 0;
		int left=dpSolution(a,i+1,j);
		int right=dpSolution(a,i+1,j+1);
		if(left<right){
			return a[i][j]+right;
		}else{
			return a[i][j]+left;
		}
	}
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext())
		{
			int n=scanner.nextInt();
			int[][] a=new int[n][n];
			for(int i=0;i<n;i++){
				for(int j=0;j<=i;j++)
					a[i][j]=scanner.nextInt();
			}
			System.out.println(dpSolution(a,0,0));
		}
		scanner.close();
	}
}

用直接递归的方法计算状态转移方程，效率往往十分低下，因为一些相同的子问题被重复计算了多次。

方法二  递推计算

import java.util.Scanner;

public class Main {
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext())
		{
			int n=scanner.nextInt();
			int[][] a=new int[n][n];
			int[][] d=new int[n][n];
			for(int i=0;i<n;i++){
				for(int j=0;j<=i;j++)
					a[i][j]=scanner.nextInt();
			}
			for(int i=0;i<n;i++)
				d[n-1][i]=a[n-1][i];
			for(int i=n-2;i>=0;i--){
				for(int j=0;j<=i;j++){
					d[i][j]+=(a[i][j]+Math.max(d[i+1][j], d[i+1][j+1]));
				}
			}
			System.out.println(d[0][0]);
		}
		scanner.close();
	}
}

方法三  记忆化搜索

import java.util.Arrays;
import java.util.Scanner;

public class Main {
	public static int dpSolution(int[][] a,int[][] d,int i,int j){
		if(i>=d.length)
			return 0;
		if(d[i][j]>=0)
			return d[i][j];
		else
			return d[i][j]=a[i][j]+Math.max(dpSolution(a,d,i+1,j),dpSolution(a,d,i+1,j+1));
	}
	public static void main(String[] args){
		Scanner scanner = new Scanner(System.in);
		while(scanner.hasNext())
		{
			int n=scanner.nextInt();
			int[][] a=new int[n][n];
			int[][] d=new int[n][n];
			for(int[] t:d)
				Arrays.fill(t, -1);
			for(int i=0;i<n;i++){
				for(int j=0;j<=i;j++)
					a[i][j]=scanner.nextInt();
			}
			System.out.println(dpSolution(a, d, 0, 0));
		}
		scanner.close();
	}
}