数据范围很小，开一个小根堆将$a,b,c,d$存进去然后每次取最小的++,重复$k$次即可

c++

#include<bits/stdc++.h>  
using namespace std;    
typedef long long ll;  

signed main() {
    ios::sync_with_stdio(0); 
    cin.tie(0), cout.tie(0); 

    int t;  
    cin >> t;  

    while (t--) {  
        int a, b, c, d, k; 
        cin >> a >> b >> c >> d >> k; 

        // 创建一个小顶堆（优先队列）
        priority_queue<int, vector<int>, greater<int>> q;  
        q.push(a);  // 将 a 插入优先队列
        q.push(b);  // 将 b 插入优先队列
        q.push(c);  // 将 c 插入优先队列
        q.push(d);  // 将 d 插入优先队列

        // k 次循环，每次从堆中取出最小元素并增加 1
        while (k--) {
            int x = q.top(); 
            q.pop();         
            ++x;            
            q.push(x);     
        }

        int res = 1; // 初始化结果变量 res
        
        while (q.size()) {
            res *= q.top(); 
            q.pop();        
        }

        cout << res << endl; 
    }
}

python

import heapq

def main():
    t = int(input())  # 读取测试用例的数量

    for _ in range(t):
        a, b, c, d, k = map(int, input().split())  # 读取 a, b, c, d, k 的值
        
        # 创建一个小顶堆（优先队列），包含 a, b, c, d
        heap = [a, b, c, d]
        heapq.heapify(heap)  # 将列表转化为堆

        # k 次循环，增加堆中最小元素的值
        for _ in range(k):
            x = heapq.heappop(heap)  # 弹出堆中最小的元素
            x += 1  # 增加该元素的值
            heapq.heappush(heap, x)  # 将增加后的元素重新放入堆中

        # 计算堆中所有元素的乘积
        res = 1
        while heap:
            res *= heapq.heappop(heap)  # 乘以堆顶元素并弹出

        print(res)  # 输出结果

if __name__ == "__main__":
    main()

java

import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t = scanner.nextInt(); // 读取测试用例数量

        while (t-- > 0) {
            int a = scanner.nextInt();
            int b = scanner.nextInt();
            int c = scanner.nextInt();
            int d = scanner.nextInt();
            int k = scanner.nextInt();

            // 使用优先队列（小顶堆）
            PriorityQueue<Integer> pq = new PriorityQueue<>();
            pq.add(a);
            pq.add(b);
            pq.add(c);
            pq.add(d);

            // 增加 k 次
            for (int i = 0; i < k; i++) {
                int x = pq.poll(); // 弹出最小值
                x++; // 增加1
                pq.add(x); // 将修改后的值重新入堆
            }

            // 计算乘积
            long res = 1; // 使用 long 类型以避免溢出
            while (!pq.isEmpty()) {
                res *= pq.poll(); // 弹出所有元素并相乘
            }

            System.out.println(res); // 输出结果
        }
        scanner.close(); // 关闭扫描器
    }
}

题目内容

给定四个正整数$a,b,c,d$。你可以进行至多$k$次操作，每次操作可以从 $a,b,c,d$ 中选择一个数，令这个数加 $1$，求操作后这四个正整数的乘积 $a * b * c * d$ 的最大值。

输入描述

输入包含多组测试数据。

输入第一行包含一个正整数$T(1≤T≤100)$，表示测试数据组数。

接下来$T$行，每行描述了一组测试数据，包含 $a,b,c,d,k(1≤a,b,c,d,k≤20)$五个整数。

输出描述

输出包含 $T$ 行。

对于每组测试数据输出一行一个整数，表示操作后这四个正整数的乘积 $a * b * c * d$ 的最大值。

样例1

输入

2
1 2 3 4 2
1 2 1 2 3

输出

72
24

说明

对于样例第一组测试数据，乘积最大为 $72$，此时操作后四个数可以分别为$2，3，3，4$。

对于样例第二组测试数据，乘积最大为 $24$，此时操作后四个数可以分别为$2，2，2，3$。