3
2 10 3
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

8 10 3
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

# 输入：数组长度和数组元素
n = int(input())
nums = list(map(int, input().split()))


def calc_bonus(nums, n):
    # 初始化奖金数组，初始值为 0
    bonuses = [0] * n

    # 初始化单调栈，用于存储数组下标
    stack = []

    # 遍历数组，计算每个元素的奖金值
    for i in range(n):
        # 当当前元素比栈顶对应的元素大时，计算栈顶元素的奖金值
        while stack and nums[stack[-1]] < nums[i]:
            idx = stack.pop()  # 弹出栈顶元素的下标
            # 计算奖金值：(i - idx) * (nums[i] - nums[idx])
            bonuses[idx] = (i - idx) * (nums[i] - nums[idx])
        # 将当前元素的下标压入栈
        stack.append(i)

    # 遍历结束后，栈中剩余的元素右侧没有比它大的元素
    while stack:
        idx = stack.pop()  # 弹出栈顶元素的下标
        bonuses[idx] = nums[idx]  # 奖金值为元素自身的值

    # 将奖金值数组转换为字符串输出
    return " ".join(map(str, bonuses))


# 输出计算结果
print(calc_bonus(nums, n))

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34

java解法

• 解题思路
• 问题描述

给定一个数组 values，对于数组中的每个元素，需要计算一个值：
从当前元素向右找到第一个比它大的元素。
如果存在这样的元素，其结果为 (index_difference) × (value_difference)：
index_difference 是两个元素的索引之差。
value_difference 是两个元素的值之差。
如果右侧不存在比当前元素更大的元素，则结果为该元素的值。
解决方案

使用 单调栈 来高效地找到右侧第一个更大的元素的索引。
栈中存储数组元素的索引和对应的值。
遍历数组时：
如果当前元素比栈顶元素大，则弹出栈顶元素，并更新弹出元素对应的结果（右侧第一个更大的元素的索引）。
将当前元素及其索引压入栈。
遍历结束后，栈中剩余的元素右侧没有更大的元素，因此其结果为元素本身。
算法流程

初始化一个栈 deque 和数组 nextGreater：
nextGreater[i] 表示元素 values[i] 右侧第一个更大的元素的索引，初始值为 -1。
遍历数组：
如果当前元素大于栈顶元素，则更新栈顶元素的 nextGreater 值，并将栈顶弹出。
将当前元素及其索引压入栈。
遍历结束后，栈中剩余的元素右侧没有更大的元素。
根据 nextGreater 数组计算每个元素的结果，并将结果存入 results。
返回结果列表的字符串表示

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt(); // 输入数组大小
        int[] values = new int[size]; // 输入数组

        // 读取数组元素
        for (int i = 0; i < size; i++) {
            values[i] = scanner.nextInt();
        }

        // 计算结果并输出
        System.out.println(calculate(values, size));
    }

    /**
     * 计算数组中每个元素的结果值
     *
     * @param values 输入数组
     * @param size   数组大小
     * @return 每个元素结果值的字符串表示
     */
    public static String calculate(int[] values, int size) {
        // 使用栈存储数组元素的索引和对应的值
        Deque<int[]> deque = new ArrayDeque<>();
        // 存储右侧第一个更大的元素的索引，初始值为 -1
        int[] nextGreater = new int[size];
        Arrays.fill(nextGreater, -1);

        // 遍历数组
        for (int i = 0; i < values.length; i++) {
            // 如果当前元素比栈顶元素大，更新栈顶元素的 nextGreater
            while (!deque.isEmpty() && deque.peek()[1] < values[i]) {
                int[] top = deque.pop(); // 弹出栈顶
                nextGreater[top[0]] = i; // 更新 nextGreater 值
            }
            // 将当前元素及其索引压入栈
            deque.push(new int[]{i, values[i]});
        }

        // 计算每个元素的结果值
        List<Integer> results = new ArrayList<>();
        for (int i = 0; i < values.length; i++) {
            // 如果右侧没有更大的元素，结果为元素本身
            if (nextGreater[i] == -1) {
                results.add(values[i]);
            } else {
                // 计算 (index_difference) × (value_difference)
                results.add((nextGreater[i] - i) * (values[nextGreater[i]] - values[i]));
            }
        }

        // 将结果列表转换为字符串
        return String.join(" ", results.stream().map(String::valueOf).toArray(String[]::new));
    }
}

 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">