数塔问题

1、问题简述

       有形如图所示的一个数塔，从顶部出发，在每一结点可以选择向左走或是向右走，一直走到底层，要求找出一条路径，使路径上的数值和最大。 

                                                                           

2、问题分析

这个问题用贪婪算法有可能会找不到真正的最大和。以图为例就是如此。用贪婪的策略，则路径和分别为9+15+8+9+10=51 （自上而下），19+2+10+12+9=52（自下而上），都得不到最优解，真正的最大和是9+12+10+18+10=59。在知道数塔的全貌的前提下，可以用枚举法或下一章将学习的搜索算法来完成。

动态规划设计过程如下：

(1) 阶段划分：第一步对于第五层的数据，我们做如下五次决策：对经过第四层2的路径选择第五层的19，对经过第四层18的路径选择第五层的10， 对经过第四层9的路径也选择第五层的10，对经过第四层5的路径选择第五层的16。

以上的决策结果将五阶数塔问题变为4阶子问题，递推出第四层与第五层的和为:21(2+19),28(18+10),19(9+10),21(5+16)。用同样的方法还可以将4阶数塔问题,变为3阶数塔问题…… 最后得到的1阶数塔问题，就是整个问题的最优解。

(2)存储、求解： 原始信息存储:原始信息有层数和数塔中的数据，层数用一个整型 变量n存储，数塔中的数据用二维数组data，存储成如 下的下三角阵:

              9

             12    15

             10     6      8

              2    18      9    5

             19     7     10    4   16

动态规划过程存储:必需用二维数组a存储各阶段的决策结果。二维数组a的存储内容如下：d[n][j]=data[n][j] ,j=1,2,……,n； i=n-1,n-2,……1，j=1,2,……,i；时 d[i][j]=max(d[i+1][j]，d[i+1][j+1])+data[i][j], 最后a[1][1]存储的就是问题的结果。

最优解路径求解及存储:仅有数组data和数组a可以找到最优解的路径， 但需要自顶向下比较数组data和数组a是可以找到。如图4.5.2求解和输出过程如下：

 输出a[1][1]"9"

  b=d[1][1]-data[1][1]=59-9=50   b与d[2][1],d[2][2] 比较

  b与d[2][1]相等输出data[2][1]"12"

  b=d[2][1]-data[2][1]=50-12=38   b与d[3][1],d[3][2] 比较

  b与d[3][1]相等输出data[3][1]"10"

  b=a[3][1]-data[3][1]=38-10=28    b与d[4][1],d[4][2] 比较

  b与d[4][2]相等输出data[4][2]"18"

  b=d[4][2]-data[4][2]=28-18=10  b与d[5][2],d[5][3] 比较

  b与d[5][3]相等输出data[5][3]"10“

 

  数组data                       数组d

    9                                59

    12  15                        50  49

    10  6   8                     38  34  29

    2   18  9   5                21  28  19  21

    19  7   10  4  16         19  7   10  4   16

为了设计简洁的算法，我们最后用三维数组a[50][50][3]存储以上确定的三个数组的信息。 

            array[50][50][1]代替数组data，

            array[50][50][2]代替数组d,

            array[50][50][3]记录解路径。

3、Java实现代码

import java.util.Scanner;
public class 数塔 {
	public static void main(String[] args) {
		int array[][][] = new int[50][50][4];
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		sc.nextLine();
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= i; j++) {
				array[i][j][1] = sc.nextInt();
				array[i][j][2] = array[i][j][1];
				array[i][j][3] = 0;
			}
			sc.nextLine();
		}
		sc.close();
		for (int i = n - 1; i >= 1; i--) {
			for (int j = 1; j <= i; j++) {
				if(array[i+1][j][2] > array[i+1][j+1][2]) {
					array[i][j][2] = array[i][j][2] + array[i+1][j][2];
					array[i][j][3] = 0;
				}else {
					array[i][j][2] = array[i][j][2] + array[i+1][j+1][2];
					array[i][j][3] = 1;
				}
			}
		}
		System.out.println("maxNum = "+array[1][1][2]);
		int j = 1;
		int i = 1;
		for (i = 1; i < n; i++) {
			System.out.print(array[i][j][1]+"-->");
			j = j + array[i][j][3];
		}
		System.out.println(array[i][j][1]);
		
	}
}