8.14动态规划例题：数字三角形

/**
 * 数字三角形(POJ1163)<br>
 *
 * 在数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。<br>
 * 路径上的每一步都只能往左下或 右下走。只需要求出这个最大和即可，不必给出具体路径。<br>
 * 三角形的行数大于1小于等于100，数字为 0 - 99<br>
 * 输入格式：<br>
 * 5 //表示三角形的行数 接下来输入三角形<br>
 * 7<br>
 * 3 8<br>
 * 8 1 0<br>
 * 2 7 4 4<br>
 * 4 5 2 6 5<br>
 * 要求输出最大和<br>
 */

递归解法：每个顶点都有两个分支可以走。顶点的值 + max(左边支路的最大值,右边支路的最大值)。
记忆化递归解法：用两个变量记录 左边支路的最大值,右边支路的最大值，如果缓存没有值便递归。
dp解法：自底向上，先把最后一层放入新数组，然后从倒数第二层开始循环到顶层，dp[][]每层的每个顶点 + max(下一层左边的值，下一层右边的值)，直接返回dp[0][0]顶点的值。

import java.util.Scanner;

public class Eight_14动态规划例题_数字三角形 {
    //递归
    private 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));
        }
    }
    //记忆型递归
    private 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;
    }
    //dp解法
    private static int maxSumUsingDp(int[][] triangle, int i, int j){
        int rowCount = triangle.length;
        int columnCount = triangle[rowCount-1].length;
        int[][] dp = new int[rowCount][columnCount];
        //最后一行
        for(int k = 0; k < columnCount; k++){
            dp[rowCount-1][k] = triangle[rowCount-1][k];
        }
        //自低向上
        for(int l = rowCount-2; l >= 0; l--){
            for(int n = 0; n <= l; n++){
                dp[l][n] = triangle[l][n] + Math.max(dp[l+1][n], dp[l+1][n+1]);
            }
        }
        return dp[0][0];
    }
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[][] triangle = new int[n][n];
        for(int i = 0; i < n; i++){
            for(int j = 0; j <= i; j++){ 
                triangle[i][j] = in.nextInt();
            }
        }
//        System.out.println(maxSumUsingRecursive(triangle, 0, 0));
//        System.out.println(maxSumUsingMemory(triangle, 0, 0, new int[n][n]));
        System.out.println(maxSumUsingDp(triangle, 0, 0));
    }
}