数字三角形（蓝桥）

题目描述

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。

路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右 边的那个数。此外，向左下走的次数与向右下走的次数相差不能超过 1。

输入描述

输入的第一行包含一个整数 � (1≤�≤100)N (1≤N≤100)，表示三角形的行数。

下面的 �N 行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数。

输出描述

输出一个整数，表示答案。

输入输出样例

示例

输入

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

输出

27

通过分析题意，在稿纸上进行模拟，我发现要想满足  题中 向左下走的次数与向右下走的次数相差不能超过 1，就必须使得走到最后一层的时候在中间，奇数的中位，偶数的中间两位的较大者。

最初的想法是逆推法，从最底下往上走，走上方或上方的左方，选取较大者进行相加。

 

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n = scan.nextInt();
        int[][] dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= i; j++) {
                dp[i][j] = scan.nextInt();
            }
        }

        int a ;//储存结果
       

        if (n % 2 == 0) {
            int a1 = n / 2;
            int a2 = n / 2 - 1;
            if(dp[n-1][a1]> dp[n-1][a2]){
                a=a1;
            }else{
                a=a2;
            }
        }
        else {
            a = (n - 1) / 2;
        }//找到逆推法的起点

        int s = dp[n - 1][a];

            for (int i = n - 2; i >= 0; i--) {
                if(a>0) {//若不在最左边，则依次选大相加
                    s += (Math.max(dp[i][a - 1], dp[i][a]));
                    if (dp[i][a - 1] > dp[i][a]) {
                        a--;//进行列的移位
                    }
                }
                else{//若到最左边，则只有一条路可走，不用选择
                    s += dp[i][0];
                }

            }
            System.out.println(s);


        }
    }

我的呕心沥血，换来的是40%的通过率，我的心碎成了八百瓣。

静下来发现我的代码确实有很多问题，比如出现相同的数取大者怎么办，显然它有问题。

去看了别人的思路

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
     public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        //在此输入您的代码...
        int n = scan.nextInt();
        int[][] dp = new int[n+1][n+1];//数组长度n+1
        for (int i = 1; i <=n; i++) {//储存从1到n
            for (int j = 1; j <= i; j++) {
                dp[i][j] = scan.nextInt();
            }
        }


        for(int i=1;i<=n;i++){
            for(int j=1;j<=i;j++){

                dp[i][j]+=Math.max(dp[i-1][j],dp[i-1][j-1]);
            }
        }//重新覆盖生成一个新数组，储存到此点的最大值

        if(n%2==0){
            System.out.println(Math.max(dp[n][n/2],dp[n][n/2+1]));
        }
        else{
            System.out.println(dp[n][(n+1)/2]);
        }

        }
    }

 这个代码的关键是数组长n+1，储存时从1开始到n，因为 递推公式中有[i-1][j-1]，所以避免了数组下标中含有-1。