用java写 小美不干外卖配送了，转行开了一家水果店。 一天她接到了一个大单，客户订购了 n 个水果，并且要求打包成多个果篮，一个果篮最多装 m 个水果。 为了包装方便，水果按从 1 到 n 编号，同一个果篮里装的水果编号必须是连续的。果篮的成本与容积成线性关系。为了估计容积，小美简单地用样本中点估计了一下。具体来说，假设一个果篮中装的最大的水果体积是 u，最小的是 v，那么这个果篮的成本就是 k × floor((u+v)/2) + s，其中 k 是果篮中装入水果的个数，s 是一个常数，floor(x) 是下取整函数，比如 floor(3.8)=3, floor(2)=2。 客户并没有规定果篮的数量，但是希望果篮的成本越小越好，毕竟买水果就很贵了。请求出小美打包这 n 个水果所用的最小花费。

好的，这道题可以使用动态规划来解决。首先定义一个二维数组 cost[i][j] 表示将前 i 个水果打包成 j 个果篮的最小花费。则状态转移方程为：

cost[i][j] = min(cost[k][j-1] + k*floor((u+v)/2) + s) (k <= i)

其中 u 表示第 k+1 到第 i 个水果中体积最大的，v 表示第 k+1 到第 i 个水果中体积最小的。

最终的答案就是 cost[n][1]，即将所有水果打包成一个果篮的最小花费。

下面是 Java 代码实现：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int s = scanner.nextInt();
        int[] a = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            a[i] = scanner.nextInt();
        }

        int[][] cost = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            cost[i][1] = cost[i - 1][1] + a[i];
        }
        for (int j = 2; j <= m; j++) {
            for (int i = j; i <= n; i++) {
                int u = a[i], v = a[i];
                int sum = a[i];
                cost[i][j] = Integer.MAX_VALUE;
                for (int k = i - 1; k >= j - 1; k--) {
                    u = Math.max(u, a[k]);
                    v = Math.min(v, a[k]);
                    sum += a[k];
                    cost[i][j] = Math.min(cost[i][j], cost[k][j - 1] + j * ((u + v) / 2) + s * j - sum);
                }
            }
        }

        System.out.println(cost[n][1]);
    }
}