承压计算【蓝桥杯】

原创于 2022-03-24 09:10:39 发布 · 354 阅读

CC 4.0 BY-SA版权

文章标签：

该博客探讨了一道数学问题，涉及将金属块按金字塔形状堆放并利用电子秤精确称重。通过复杂的计算过程，将30层金属块的重量平均分配到最底层的30台电子秤上，最终找到最大和最小的电子秤读数。博客内容包括对数据处理的技巧，如数据类型范围的掌握和复杂问题简化，以及如何将正三角形数据转换为便于处理的格式。核心代码展示了如何进行计算，最后得出最大读数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

X 星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同，金属材料被严格地堆放成金字塔形。

其中的数字代表金属块的重量（计量单位较大），最下一层的 X 代表 30 台极高精度的电子秤。

假设每块原料的重量都十分精确地平均落在下方的两个金属块上，

最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。

电子秤的计量单位很小，所以显示的数字很大，工作人员发现，其中读数最小的电子秤的示数为：2086458231

请你推算出：读数最大的电子秤的示数为多少？
————————————————

                             7 
                            5 8 
                           7 8 8 
                          9 2 7 2 
                         8 1 4 9 1 
                        8 1 8 8 4 1 
                       7 9 6 1 4 5 4 
                      5 6 5 5 6 9 5 6 
                     5 5 4 7 9 3 5 5 1 
                    7 5 7 9 7 4 7 3 3 1 
                   4 6 4 5 5 8 8 3 2 4 3 
                  1 1 3 3 1 6 6 5 5 4 4 2 
                 9 9 9 2 1 9 1 9 2 9 5 7 9 
                4 3 3 7 7 9 3 6 1 3 8 8 3 7 
               3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 
              8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 
             8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 
            2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
           7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
          9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
         5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
        6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
       2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
      7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
     1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 
    2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 
   7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 
  7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 
 5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 
X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X

考察点：对数据类型范围的掌握以及将复杂问题简单化的能力。

注意：

1.因为这个题中每个数都要除2，并且有30行，计算前必须先给每个值乘2的30次方，这样才能保证在向下运算过程中没有数据丢失。

2.处理数据比较多的问题时一定要注意数据的边界问题。

思路：考虑到正三角形在程序中的输入问题，将正三角形转化为如下所示：

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

这样方便程序读入数据！

核心思路代码：

long factor = (long) Math.pow(2,30);
        for ( int i = 0; i < 29; i++ ){
            for ( int j = 0; j <= i; j++ ){
                long aa = sc.nextLong();
                a[i][j] = aa*factor;
            }
        }

        for ( int i = 0; i < 29; i++ ){
            for ( int j = 0; j <= i; j++ ){
                long div = a[i][j]/2;
                a[i+1][j] += div;
                a[i+1][j+1] += div;
            }
        }

全部代码如下：

package pastExamPaper;

import javax.security.sasl.SaslClient;
import java.util.Arrays;
import java.util.Scanner;

/*
    承压计算
    收获：1.因为这个题中每个数都要除2，并且有30行，计算前必须先给每个值乘2的30次方，这样才能保证在向下运算过程中没有数据丢失。
         2.处理数据比较多的问题时一定要注意数据的边界问题。
 */
public class Demo87 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long[][] a = new long[30][30];
//        long factor = 1;
//        for (int i = 0; i < 30; i++ ){
//            factor<<=1;
//        }
        long factor = (long) Math.pow(2,30);
        for ( int i = 0; i < 29; i++ ){
            for ( int j = 0; j <= i; j++ ){
                long aa = sc.nextLong();
                a[i][j] = aa*factor;
            }
        }

        for ( int i = 0; i < 29; i++ ){
            for ( int j = 0; j <= i; j++ ){
                long div = a[i][j]/2;
                a[i+1][j] += div;
                a[i+1][j+1] += div;
            }
        }

//        long min = Long.MAX_VALUE;
//        long max = 0;
//        for ( int i = 0; i < 30; i++ ){
//            if (a[29][i] < min){
//                min = a[29][i];
//            }
//            if (a[29][i] > max){
//                max = a[29][i];
//            }
//            System.out.print(a[29][i]+" ");
//        }

        Arrays.sort(a[29]);

        System.out.println();
        System.out.println("最小的数为："+a[29][0]);
        System.out.println("最大的数为："+a[29][29]);
//        System.out.println("所求结果为："+(2086458231/a[29][0])*a[29][29]);//84849301394

        System.out.println(a[29][29]/(a[29][0]/2086458231));//最终答案为72665192664
    }
}
/*
7
5 8
7 8 8
9 2 7 2
8 1 4 9 1
8 1 8 8 4 1
7 9 6 1 4 5 4
5 6 5 5 6 9 5 6
5 5 4 7 9 3 5 5 1
7 5 7 9 7 4 7 3 3 1
4 6 4 5 5 8 8 3 2 4 3
1 1 3 3 1 6 6 5 5 4 4 2
9 9 9 2 1 9 1 9 2 9 5 7 9
4 3 3 7 7 9 3 6 1 3 8 8 3 7
3 6 8 1 5 3 9 5 8 3 8 1 8 3 3
8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9
8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4
2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9
7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6
9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3
5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9
6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4
2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4
7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6
1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3
2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8
7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9
7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6
5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1
 */