codeforces 571 B. Minimization

最新推荐文章于 2019-07-25 17:16:02 发布

whai362

最新推荐文章于 2019-07-25 17:16:02 发布

阅读量833

点赞数

CC 4.0 BY-SA版权

分类专栏：动态规划文章标签： algorithm dp

本文链接：https://blog.youkuaiyun.com/whai362/article/details/47959203

动态规划专栏收录该内容

20 篇文章

订阅专栏

本文探讨了一个算法问题，目标是在给定数组和一个整数k的情况下，通过重新排列数组元素来最小化数组元素之和。具体地，算法通过计算不同长度子数组的前缀和，利用动态规划技巧dp[i][j]表示取i个长度为k+1的子数组和j个长度为k的子数组时的最小代价，最终输出最小可能的和。

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

You've got array A, consisting of n integers and a positive integer k. Array A is indexed by integers from 1 to n.

You need to permute the array elements so that value

$\text{[math]}$ became minimal possible. In particular, it is allowed not to change order of elements at all.

Input

The first line contains two integers n, k (2 ≤ n ≤ 3·105, 1 ≤ k ≤ min(5000, n - 1)).

The second line contains n integers A[1], A[2], ..., A[n] ( - 109 ≤ A[i] ≤ 109), separate by spaces — elements of the array A.

Output

Print the minimum possible value of the sum described in the statement.

Sample test(s)

input
3 2
1 2 4

output
1

input
5 2
3 -5 3 -5 3

output
0

input
6 3
4 3 4 3 2 5

output
3

Note

In the first test one of the optimal permutations is 1 4 2.

In the second test the initial order is optimal.

In the third test one of the optimal permutations is 2 3 4 4 3 5.

思路：
令sz = n/k
可以发现：
有n % k个长度为sz + 1的，有k - n % k 个长度为sz的
dp[i][j]表示取i个长度为sz + 1的和j个长度为sz的最小代价

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;

#define LL __int64

const LL INF = 10000000000000000LL;
const int N = 3 * 1e5 + 5;
const int M = 5005;

LL a[N], pre[N];
LL dp[M][M];

void init(int n) {
	pre[0] = pre[1] = 0;
	for(int i = 2; i <= n; ++i) {
		pre[i] = pre[i - 1] + a[i] - a[i - 1];
	}
	for(int i = 0; i < M; ++i) {
		for(int j = 0; j < M; ++j) {
			dp[i][j] = INF;
		}
	}
}

int main() {
	int n, k;
	cin>>n>>k;
	for(int i = 1; i <= n; ++i)
		cin>>a[i];
	sort(a + 1, a + 1 + n);

	int sz = n / k;
	int u = n % k;
	int v = k - u;

	init(n);

	dp[0][0] = 0;
	for(int i = 0; i <= u; ++i) {
		for(int j = 0; j <= v; ++j) {
			int x = i * (sz + 1) + j * sz + 1;
			dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + pre[x + sz] - pre[x]);
			dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + pre[x + sz - 1] - pre[x]);
		}
	}
	cout<<dp[u][v]<<endl;
	return 0;
}