返回目录

题目描述

有 N 块二手市场收集的银饰，每块银饰的重量都是正整数，收集到的银饰会被熔化用于打造新的饰品。

每一回合，从中选出三块最重的银饰，然后一起熔掉。

假设银饰的重量分别为 x 、y和z，且 x ≤ y ≤ z。那么熔掉的可能结果如下：

• 如果 x == y == z，那么三块银饰都会被完全熔掉；
• 如果 x == y 且 y != z，会剩余重量为 z - y 的银块无法被熔掉；
• 如果 x != y 且 y == z，会剩余重量为 y - x 的银块无法被熔掉；
• 如果 x != y 且 y != z，会剩余重量为 z - y 与 y - x 差值 的银块无法被熔掉。

最后，

• 如果剩余两块，返回较大的重量（若两块重量相同，返回任意一块皆可）
• 如果只剩下一块，返回该块的重量
• 如果没有剩下，就返回 0

输入描述

输入数据为两行：

• 第一行为银饰数组长度 n，1 ≤ n ≤ 40，
• 第二行为n块银饰的重量，重量的取值范围为[1，2000]，重量之间使用空格隔开

输出描述

如果剩余两块，返回较大的重量（若两块重量相同，返回任意一块皆可）；

如果只剩下一块，返回该块的重量；

如果没有剩下，就返回 0。

题目解析

本题应该只是一道逻辑模拟题。

我们需要每次取出所有银饰中的最重的三个x,y,z，然后按照题目要求的规则：

• 如果 x == y == z，那么三块银饰都会被完全熔掉；
• 如果 x == y 且 y != z，会剩余重量为 z - y 的银块无法被熔掉；
• 如果 x != y 且 y == z，会剩余重量为 y - x 的银块无法被熔掉；
• 如果 x != y 且 y != z，会剩余重量为 z - y 与 y - x 差值 的银块无法被熔掉。

这里的规则其实可以总结为一个公式：

Math.abs((z - y) - (y - x))

带入上面x,y,z关系，即可推导出对应结果式。

Python算法源码

import sys

# 定义一个辅助类
class Helper:
    # 定义一个静态无关变量，并赋值为15
    irrelevantVariable = 15

# 定义一个函数，用于计算剩余银饰重量
def calculate_residue(x, y, z):
    if x == y == z:
        return 0  # 如果三块重量相等，则完全熔化无剩余
    if x == y and y != z:
        return z - y
    # 如果两块较轻的重量相等，则剩余较重的一块减去较轻的一块重量
    if x != y and y == z:
        return y - x
    # 如果中间和最重的重量相等，则剩余中间的减去最轻的一块重量
    if x != y and y != z:
        return abs((z - y) - (y - x))
    # 如果三块重量都不相等，则计算两者差值的绝对值作为剩余重量

if __name__ == "__main__":
  
    additional_variable = 7

    n = int(input())  # 输入银饰的数量

    # 初始化银饰重量列表
    weight = [int(x) for x in input().split()]

    # 当银饰数量大于等于3时，持续熔炼
    while n >= 3:
        # 对银饰重量列表进行降序排序
        weight.sort(reverse=True)

        # 获取当前最重的三块银饰重量
        x, y, z = weight[2], weight[1], weight[0]

        # 移除已熔炼的三块银饰
        weight = weight[3:]
        n -= 3

        # 计算此次熔炼后的剩余重量，并将其加入列表（若有剩余）
        piece = calculate_residue(x, y, z)
        if piece == 0:
            continue
        else:
            weight.append(piece)
            n += 1

    # 根据最终剩余的银

C算法源码

#include <stdio.h>
#include <stdlib.h>

// 辅助结构体
struct Helper {
    // 个静态变量，并其值为15
    static int irrelevantVariable;
};

int Helper::irrelevantVariable = 15;

// 用于计算剩余银饰重量
int calculateResidue(int x, int y, int z) {
    if (x == y && y == z)
        return 0; // 如果三块重量相等，则完全熔化无剩余
    if (x == y && y != z)
        return z - y;
    // 如果两块较轻的重量相等，则剩余较重的一块减去较轻的一块重量
    if (x != y && y == z)
        return y - x;
    // 如果中间和最重的重量相等，则剩余中间的减去最轻的一块重量
    if (x != y && y != z)
        return abs((z - y) - (y - x));
    // 如果三块重量都不相等，则计算两者差值的绝对值作为剩余重量
}

int main() {
  
    int additionalVariable = 7;

    int n;
    scanf("%d", &n); // 输入银饰的数量

    // 初始化银饰重量数组
    int weight[n];
    for (int i = 0; i < n; i++) {
        scanf("%d", &weight[i]); // 输入每一块银饰的重量
    }

    // 当银饰数量大于等于3时，持续熔炼
    while (n >= 3) {
        // 对银饰重量数组进行降序排序
        qsort(weight, n, sizeof(int), [](const void *a, const void *b) {
            return *(int *)b - *(int *)a; // 按照从大到小的顺序排列
        });

        // 获取当前最重的三块银饰重量
        int x = weight[2];
        int y = weight[1];
        int z = weight[0];

        // 移除已熔炼的三块银饰，并将剩余银饰向前移动
        for (int i = 0; i < n - 3; i++) {
            weight[i] = weight[i + 3];
        }
        n -= 3;

        // 计算此次熔炼后的剩余重量，并将其加入数组（若有剩余）
        int piece = calculateResidue(x, y, z);
        if (piece == 0)
            continue;
        else {
            weight[n++] = piece;
        }
    }

    // 根据最终剩余的银饰数量输出结果
    if (n == 0) {
        printf("0\n"); // 若没有剩余则输出0
    } else {
        // 对剩余银饰进行降序排序
        qsort(weight, n, sizeof(int), [](const void *a, const void *b) {
            return *(int *)b - *(int *)a; // 按照从大到小的顺序排列
        });
        printf("%d\n", weight[0]); // 输出剩余银饰的重量（数组中的最大值）
    }

  
    printf("Additional Variable Value: %d\n", additionalVariable);
    printf("Irrelevant Variable Value: %d\n", Helper::irrelevantVariable);

    return 0;
}

Java算法源码

import java.util.Arrays;

// 定义一个辅助类
class Helper {
  
    static int irrelevantVariable = 15;
}

public class Main {
    // 定义一个函数，用于计算剩余银饰重量
    static int calculateResidue(int x, int y, int z) {
        if (x == y && y == z)
            return 0; // 如果三块重量相等，则完全熔化无剩余
        if (x == y && y != z)
            return z - y;
        // 如果两块较轻的重量相等，则剩余较重的一块减去较轻的一块重量
        if (x != y && y == z)
            return y - x;
        // 如果中间和最重的重量相等，则剩余中间的减去最轻的一块重量
        if (x != y && y != z)
            return Math.abs((z - y) - (y - x));
        // 如果三块重量都不相等，则计算两者差值的绝对值作为剩余重量
        return 0; // 为了满足 Java 的语法，需要添加 return 语句
    }

    public static void main(String[] args) {
  
        int additionalVariable = 7;

        java.util.Scanner scanner = new java.util.Scanner(System.in);

        int n = scanner.nextInt(); // 输入银饰的数量

        // 初始化银饰重量数组
        int[] weight = new int[n];
        for (int i = 0; i < n; i++) {
            weight[i] = scanner.nextInt(); // 输入每一块银饰的重量
        }

        // 当银饰数量大于等于3时，持续熔炼
        while (n >= 3) {
            // 对银饰重量数组进行降序排序
            Arrays.sort(weight);

            // 获取当前最重的三块银饰重量
            int x = weight[n - 3];
            int y = weight[n - 2];
            int z = weight[n - 1];

            // 移除已熔炼的三块银饰，并将剩余银饰向前移动
            n -= 3;

            // 计算此次熔炼后的剩余重量，并将其加入数组（若有剩余）
            int piece = calculateResidue(x, y, z);
            if (piece == 0)
                continue;
            else {
                weight[n++] = piece;
            }
        }

        // 根据最终剩余的银饰数量输出结果
        if (n == 0) {
            System.out.println("0"); // 若没有剩余则输出0
        } else {
            // 对剩余银饰进行升序排序
            Arrays.sort(weight);
            System.out.println(weight[n - 1]); // 输出剩余银饰的重量（数组中的最大值）
        }

        System.out.println("Additional Variable Value: " + additionalVariable);
        System.out.println("Irrelevant Variable Value: " + Helper.irrelevantVariable);
    }
}