2023-07-17：给定一个数组arr，长度为n， 再给定一个数字k，表示一定要将arr划分成k个集合， 每个数字只能进一个集合。 返回每个集合内部的平均值都累加起来最小的值。 平均值向下取整。 1
2023-07-17：给定一个数组arr，长度为n，
再给定一个数字k，表示一定要将arr划分成k个集合，
每个数字只能进一个集合。
返回每个集合内部的平均值都累加起来最小的值。
平均值向下取整。
1 <= n <= 10^5，
0 <= arr[i] <= 10^5，
1 <= k <= n。
真实大厂笔试题。
答案2023-07-17：
算法1（minAverageSum1）：
1.定义一个结构体Info，包含两个字段：sum表示集合内所有元素的和，cnt表示集合内元素的个数。
2.定义函数minAverageSum1(arr []int, k int) int，接收数组arr和整数k作为参数，返回最小平均值累加和。
3.若数组arr的长度小于k，返回-1。
4.创建一个长度为k的Info类型的切片sets，用于存储k个集合的信息。
5.调用递归函数process(arr, 0, k, sets)来计算最小平均值累加和。
6.函数process(arr []int, i int, k int, sets []Info) int表示将arr数组从索引i开始的元素划分到sets集合中，返回最小平均值累加和。
7.若i等于arr的长度，表示所有元素都已经划分完毕，计算集合内元素的平均值并返回。
8.初始化最小平均值累加和ans为最大整数值。
9.取出当前元素arr[i]，遍历sets集合的每个元素。
10.将arr[i]加到sets[j]集合的sum字段上，同时增加sets[j]集合的cnt字段。
11.递归调用process(arr, i+1, k, sets)，传递更新后的sets集合。将返回结果与ans比较并更新ans。
12.回溯操作，将之前加入arr[i]的sum和cnt字段还原。
13.返回ans作为最终结果。
算法2（minAverageSum2）：
1.定义函数minAverageSum2(arr []int, k int) int，接收数组arr和整数k作为参数，返回最小平均值累加和。
2.若数组arr的长度小于k，返回-1。
3.对数组arr进行升序排序。
4.初始化ans为0，用于记录平均值累加和的结果。
5.遍历排序后的arr数组，从索引0到k-2。
6.将arr[i]累加到ans上。
7.计算剩余元素的和sum，从索引k-1到数组末尾。
8.将sum除以剩余元素个数（len(arr)-k+1），并向下取整，累加到ans上。
9.返回ans作为最终结果。
测试部分：
1.设置常量N为8、V为10000，表示测试样例的大小范围。
2.设置常量testTimes为2000，表示测试次数。
3.打印"测试开始"。
4.循环testTimes次进行测试：
-
随机生成一个1到N之间的数作为数组长度n。
-
使用函数randomArray(n, V)随机生成一个长度为n，元素值介于0到V之间的数组arr。
-
随机生成一个1到n之间的数作为集合的个数k。
-
调用minAverageSum1(arr, k)得到算法1的结果ans1。
-
调用minAverageSum2(arr, k)得到算法2的结果ans2。
-
若ans1与ans2不相等，打印"出错了!"。
5.打印"测试结束"。
算法1（minAverageSum1）的时间复杂度和空间复杂度如下：
-
时间复杂度：这个算法的时间复杂度是指数级的，具体为O(k^n)，其中n是数组arr的长度。因为算法使用了递归来穷举所有可能的划分方式，而对于每个划分方式，需要计算集合内元素的和。因此，时间复杂度随着n的增加呈指数级增长。
-
空间复杂度：这个算法的空间复杂度取决于递归调用的深度，即划分的次数。在每次递归调用时，都会创建一个Info类型的切片sets，因此空间复杂度与递归调用的深度成正比，即O(k)。此外，还需要额外的空间来存储函数参数和临时变量，因此可以忽略不计。
算法2（minAverageSum2）的时间复杂度和空间复杂度如下：
-
时间复杂度：这个算法的时间复杂度是O(nlogn)，其中n是数组arr的长度。算法首先对数组arr进行排序，排序的时间复杂度为O(nlogn)。然后对排序后的数组进行遍历，遍历的时间复杂度为O(n)。因此，总体的时间复杂度为O(nlogn)。
-
空间复杂度：这个算法的空间复杂度主要由排序所需的额外空间决定，即O(n)。在排序过程中，可能需要额外的空间来存储临时变量和排序结果，但这个空间复杂度可以忽略不计。因此，总体的空间复杂度为O(n)。
go完整代码如下：
package main
import (
"fmt"
"math"
"math/rand"
"sort"
)
type Info struct {
sum int
cnt int
}
func minAverageSum1(arr []int, k int) int {
if len(arr) < k {
return -1
}
sets := make([]Info, k)
return process(arr, 0, k, sets)
}
func process(arr []int, i int, k int, sets []Info) int {
if i == len(arr) {
ans := 0
for _, set := range sets {
if set.cnt == 0 {
return math.MaxInt32
} else {
ans += set.sum / set.cnt
}
}
return ans
} else {
ans := math.MaxInt32
cur := arr[i]
for j := 0; j < k; j++ {
sets[j].sum += cur
sets[j].cnt += 1
ans = min(ans, process(arr, i+1, k, sets))
sets[j].sum -= cur
sets[j].cnt -= 1
}
return ans
}
}
func min(a, b int) int {
if a < b {
return a
} else {
return b
}
}
func minAverageSum2(arr []int, k int) int {
if len(arr) < k {
return -1
}
sort.Ints(arr)
ans := 0
for i := 0; i < k-1; i++ {
ans += arr[i]
}
sum := 0
for i := k - 1; i < len(arr); i++ {
sum += arr[i]
}
ans += sum / (len(arr) - k + 1)
return ans
}
func randomArray(n int, v int) []int {
arr := make([]int, n)
for i := 0; i < n; i++ {
arr[i] = rand.Intn(v)
}
return arr
}
func main() {
N := 8
V := 10000
testTimes := 2000
fmt.Println("测试开始")
for i := 0; i < testTimes; i++ {
n := rand.Intn(N) + 1
arr := randomArray(n, V)
k := rand.Intn(n) + 1
ans1 := minAverageSum1(arr, k)
ans2 := minAverageSum2(arr, k)
if ans1 != ans2 {
fmt.Println("出错了!")
}
}
fmt.Println("测试结束")
}
rust完整代码如下：
use std::cmp;
#[derive(Clone)]
struct Info {
sum: i32,
cnt: i32,
}
impl Info {
fn new(s: i32, c: i32) -> Info {
Info { sum: s, cnt: c }
}
}
fn min_average_sum1(arr: &[i32], k: usize) -> i32 {
if arr.len() < k {
return -1;
}
let mut sets = vec![Info::new(0, 0); k];
process(arr, 0, k, &mut sets)
}
fn process(arr: &[i32], i: usize, k: usize, sets: &mut Vec<Info>) -> i32 {
if i == arr.len() {
let mut ans = 0;
for set in sets {
if set.cnt == 0 {
return i32::max_value();
} else {
ans += set.sum / set.cnt;
}
}
return ans;
} else {
let mut ans = i32::max_value();
let cur = arr[i];
for j in 0..k {
sets[j].sum += cur;
sets[j].cnt += 1;
ans = cmp::min(ans, process(arr, i + 1, k, sets));
sets[j].sum -= cur;
sets[j].cnt -= 1;
}
return ans;
}
}
fn min_average_sum2(arr: &[i32], k: usize) -> i32 {
if arr.len() < k {
return -1;
}
let mut sorted_arr = arr.to_vec();
sorted_arr.sort();
let mut ans = 0;
for i in 0..(k - 1) {
ans += sorted_arr[i];
}
let mut sum = 0;
for i in (k - 1)..arr.len() {
sum += sorted_arr[i];
}
ans += sum / (arr.len() - k + 1) as i32;
ans
}
fn random_array(n: usize, v: i32) -> Vec<i32> {
let mut ans = vec![0; n];
for i in 0..n {
ans[i] = rand::random::<i32>() % v;
}
ans
}
fn main() {
const N: usize = 8;
const V: i32 = 10000;
const TEST_TIMES: usize = 2000;
println!("测试开始");
for _ in 0..TEST_TIMES {
let n = rand::random::<usize>() % N + 1;
let arr = random_array(n, V);
let k = rand::random::<usize>() % n + 1;
let ans1 = min_average_sum1(&arr, k);
let ans2 = min_average_sum2(&arr, k);
if ans1 != ans2 {
println!("出错了!");
}
}
println!("测试结束");
}
c++完整代码如下：
#include <iostream>
#include <vector>
#include <algorithm>
struct Info {
int sum;
int cnt;
Info(int s, int c) : sum(s), cnt(c) {}
};
int process(const std::vector<int>& arr, int i, int k, std::vector<Info>& sets) {
if (i == arr.size()) {
int ans = 0;
for (const auto& set : sets) {
if (set.cnt == 0) {
return INT_MAX;
}
else {
ans += set.sum / set.cnt;
}
}
return ans;
}
else {
int ans = INT_MAX;
int cur = arr[i];
for (int j = 0; j < k; j++) {
sets[j].sum += cur;
sets[j].cnt += 1;
ans = std::min(ans, process(arr, i + 1, k, sets));
sets[j].sum -= cur;
sets[j].cnt -= 1;
}
return ans;
}
}
int minAverageSum1(const std::vector<int>& arr, int k) {
if (arr.size() < k) {
return -1;
}
std::vector<Info> sets(k, Info(0, 0));
return process(arr, 0, k, sets);
}
int minAverageSum2(const std::vector<int>& arr, int k) {
if (arr.size() < k) {
return -1;
}
std::vector<int> sortedArr = arr;
std::sort(sortedArr.begin(), sortedArr.end());
int ans = 0;
for (int i = 0; i < k - 1; i++) {
ans += sortedArr[i];
}
int sum = 0;
for (int i = k - 1; i < sortedArr.size(); i++) {
sum += sortedArr[i];
}
ans += sum / (sortedArr.size() - k + 1);
return ans;
}
std::vector<int> randomArray(int n, int v) {
std::vector<int> arr(n);
for (int i = 0; i < n; i++) {
arr[i] = rand() % v;
}
return arr;
}
int main() {
int N = 8;
int V = 10000;
int testTimes = 2000;
std::cout << "测试开始" << std::endl;
for (int i = 0; i < testTimes; i++) {
int n = rand() % N + 1;
std::vector<int> arr = randomArray(n, V);
int k = rand() % n + 1;
int ans1 = minAverageSum1(arr, k);
int ans2 = minAverageSum2(arr, k);
if (ans1 != ans2) {
std::cout << "出错了!" << std::endl;
}
}
std::cout << "测试结束" << std::endl;
return 0;
}
c完整代码如下：
#include <stdio.h>
#include <stdlib.h>
typedef struct {
int sum;
int cnt;
} Info;
int process(int arr[], int n, int i, int k, Info sets[]) {
if (i == n) {
int ans = 0;
for (int j = 0; j < k; j++) {
if (sets[j].cnt == 0) {
return INT_MAX;
}
else {
ans += sets[j].sum / sets[j].cnt;
}
}
return ans;
}
else {
int ans = INT_MAX;
int cur = arr[i];
for (int j = 0; j < k; j++) {
sets[j].sum += cur;
sets[j].cnt += 1;
ans = (ans < process(arr, n, i + 1, k, sets)) ? ans : process(arr, n, i + 1, k, sets);
sets[j].sum -= cur;
sets[j].cnt -= 1;
}
return ans;
}
}
int minAverageSum1(int arr[], int n, int k) {
if (n < k) {
return -1;
}
Info* sets = (Info*)malloc(k * sizeof(Info));
for (int i = 0; i < k; i++) {
sets[i].sum = 0;
sets[i].cnt = 0;
}
int result = process(arr, n, 0, k, sets);
free(sets);
return result;
}
int compare(const void* a, const void* b);
int minAverageSum2(int arr[], int n, int k) {
if (n < k) {
return -1;
}
qsort(arr, n, sizeof(int), compare); // 需要包含stdlib.h以及compare函数的实现
int ans = 0;
for (int i = 0; i < k - 1; i++) {
ans += arr[i];
}
int sum = 0;
for (int i = k - 1; i < n; i++) {
sum += arr[i];
}
ans += sum / (n - k + 1);
return ans;
}
// 用于比较的函数
int compare(const void* a, const void* b) {
return (*(int*)a - *(int*)b);
}
// 生成随机数组
int* randomArray(int n, int v) {
int* arr = (int*)malloc(n * sizeof(int));
for (int i = 0; i < n; i++) {
arr[i] = rand() % v;
}
return arr;
}
int main() {
int N = 8;
int V = 10000;
int testTimes = 2000;
printf("测试开始\n");
for (int i = 0; i < testTimes; i++) {
int n = rand() % N + 1;
int* arr = randomArray(n, V);
int k = rand() % n + 1;
int ans1 = minAverageSum1(arr, n, k);
int ans2 = minAverageSum2(arr, n, k);
if (ans1 != ans2) {
printf("出错了！\n");
}
free(arr);
}
printf("测试结束\n");
return 0;
}
