动态规划算法之数塔问题

package cn.gldwolf.bigdata;

/*
3
12  56
23  4   78
34  69  34  19
12  3   54  12  34
*/

/*
思路：从最底层往上走，判断下层两个节点中的最大值，
并将最大值与上层节点中的值相加得到这一步的最大值，
将最大值保存到新的数塔中
再判断上层节点的的两个节点的最大值，
再与上上层的节点相加，再保存到新的数塔中，
如此循环往复，最终得到顶层节点的值一定为最大值。

输出路径时：
将两个数塔相减，得到下一个节点的值，
下一个节点的值的下标要么和上层节点的下标一致，
要么为上层节点的下标 +1
*/

import java.util.Scanner;

public class NumberTower {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Please input the tower height: ");
        int height = input.nextInt();
        int firIndex = height - 1; // 数组的长度
        int[][] orignal = new int[height][]; // 原始的数塔数组
        int[][] ultima = new int[height][]; // 求最大值以后的数塔数组
        System.out.println(orignal.length);

        System.out.println("Please input the number for the number tower: ");
        // 生成数塔数据
        for (int i = 0; i < orignal.length; i++) {
            orignal[i] = new int[i + 1];
            for (int j = 0; j <= i; j++) {
                orignal[i][j] = input.nextInt();
            }
        }

        createUltimaArray(firIndex, orignal, ultima);
        printTrace(firIndex, orignal, ultima);
    }

    // 生成求完最大值后的数塔数组
    public static void createUltimaArray(int firIndex, int[][] orignal, int[][] ultima) {

        // 将原始数塔中的数据加载到 ultima 数塔中
        for (int i = 0; i < orignal.length; i++) {
            ultima[i] = new int[i + 1];
            for (int j = 0; j <= i; j++) {
                ultima[i][j] = orignal[i][j];
            }
        }

        // 定义一个临时变量保存下层节点中两个值中的最大值
        int temp_max;

        // 判断下层两个节点中的最大值，并将最大值与节点中的原始数值相加并保存
        for (int i = firIndex - 1; i >= 0; --i) {
            for (int j = 0; j <= i; ++j) {
                temp_max = Math.max(ultima[i + 1][j], ultima[i + 1][j + 1]);
                ultima[i][j] = temp_max + orignal[i][j];
            }
        }
    }

    public static void printTrace(int firIndex, int[][] orignal, int[][] ultima) {
        int max = ultima[0][0];
        System.out.print(orignal[0][0]); // 第一个节点的值是确定的
        int j = 0; // 确定初始的二维下标，并提供后续控制  // 这个地方很关键
        // 循环判断
        for (int i = 1; i <= firIndex; i++) {
            // 用 ultima 数组和 orginal 数组相减，得到其子节点在 ultima 数组中的值
            int node = ultima[i - 1][j] - orignal[i - 1][j];
            // 因为对上层节点而言，其子节点只有两个，要么和它下标一致，要么为其下标 +1
            if (node != ultima[i][j])  // 判断，如果和它相同的下标不对，则对下层的下标 +1
                ++j;
            System.out.print(" --> " + orignal[i][j]);
        }
    }
}