“字符串子串”是网易2017年校园招聘题。
题目:
一种双核CPU的两个核能够同时的处理任务,现在有n个已知数据量的任务需要交给CPU处理,假设已知CPU的每个核1秒可以处理1kb,每个核同时只能处理一项任务。n个任务可以按照任意顺序放入CPU进行处理,现在需要设计一个方案让CPU处理完这批任务所需的时间最少,求这个最小的时间。
输入描述:
输入包括两行:
第一行为整数n(1 ≤ n ≤ 50)
第二行为n个整数length[i](1024 ≤ length[i] ≤ 4194304),表示每个任务的长度为length[i]kb,每个数均为1024的倍数。
输出描述:
输出一个整数,表示最少需要处理的时间
输入例子1:
5
3072 3072 7168 3072 1024
输出例子1:
9216
解决思路
首先,我们先认真审题,看看需要注意的地方:
1.CPU是双核的,每个核同时只能处理一项任务,并且1秒可以处理1kb;
2.有n个已知的数据量要交给CPU处理,n个任务可以按照任意顺序放入CPU中处理;
3.目的:设计一个方案,让CPU处理完这n个任务所需的时间最少,并求这个最小的时间。
4.输入值:整数n(1 ≤ n ≤ 50),n个整数length[i](1024 ≤ length[i] ≤ 4194304),每个数均为1024的倍数。
5.输出值:最少需要处理的时间
理解完题目的意思后,我们发现,要使得CPU处理完这n个任务所需的时间最少,那么,我们就应该充分地利用这2个核,即,同一时间,尽可能地让两个核都在工作,这样就可以最小化处理时间。
那么,如何尽可能保证两个核在同一时间都在工作呢?
我想到一种方案,就是长度大的任务必须优先处理。即,我们可以先对任务长度进行排序,两个核再依次从大到小处理任务。
public class Substring {
public int substring(int n, int[] length){
//输入值合法性验证
if(n < 1 || n > 50)
throw new IllegalArgumentException("输入值n不合法");
if(length.length != n)
throw new IllegalArgumentException("输入值length不合法");
for(int i = 0;i < n;i++){
if(length[i] < 1024 || length[i] > 4194304 || length[i] % 1024 != 0)
throw new IllegalArgumentException("输入值length不合法");
}
//利用快排对length排序
quickSort(length, 0, n-1);
int time = 0;
int core1 = n-1;//第一个核先处理最大长度的任务
int core2 = n-2;
int temp1 = length[core1];
int temp2 = 0;
while(core1 > 0 && core2 > 0){
temp2 = 0;
for(int j = core1-1;j >= 0;--j){
core2 = j;//第二个核处理length[j]
if((temp2+length[core2]) > temp1){
temp2 += length[core2] - temp1;//core1处理完任务后,core2还剩多少长度任务没处理
time += length[core2]-temp2;//累加已经处理的部分
break;
}else{
temp2 += length[core2];
time += length[core2];
}
}
if(core2 == 0) //如果此时core2已经处理完最后一个任务,则结束
break;
temp1 = 0;
for (int i = core2-1;i >= 0;--i){
core1 = i;
if((temp1+length[core1]) > temp2){
temp1 += length[core1] - temp2;//core2处理完任务后,core1还剩多少长度任务没处理
time += length[core1]-temp1;//累加已经处理的部分;
break;
}else{
temp1 += length[core1];
time += length[core1];
}
}
}
//累加最后一个任务没有处理完的部分
if(core1 == 0)
time += (temp2-temp1);
else if(core2 == 0)
time += (temp1-temp2);
return time;
}
/*
*快速排序
* // 时间复杂度:T(n)=O(nlogn)
// 空间复杂度:S(n) = O(logn)
// 稳定性:不稳定排序
*/
void quickSort(int arr[], int start, int end) {
if(start < end){//判断start是否等于end,如果等于则说明各区间只有一个数
int i = start;
int j = end;
int x = arr[start];//将start作为基准数
while(i < j){//如果i=j,则结束
while(i < j && arr[j] >= x) // 从右向左找第一个小于x的数
j--;
//此时,arr[j] < x,则令arr[i]=arr[j],且i向前移动一格
if(i < j)
arr[i++] = arr[j];
while(i < j && arr[i] < x)// 从左向右找第一个大于等于x的数
i++;
//此时,arr[i] >= x,则令arr[j]=arr[i],且j向后移动一格
if(i < j)
arr[j--] = arr[i];
}
//此时,arr[i]=arr[j]=x,且比x大的数全在它的右边,小于或等于它的数全在其左边。下面则再对其左右区间重复这个步骤
arr[i] = x;
quickSort(arr,start,i-1);//对其左边区间重复上述操作
quickSort(arr,i+1,end);//对其右边区间重复上述操作
}
}
public static void main(String[] args) {
Substring substring = new Substring();
int n = 5;
int[] length = {3072,3072,7168,3072,1024};
int time = substring.substring(n,length);
System.out.print(time);
}
}
排序的时候,我选择了快速排序,因此排序的时间复杂度为 O(nlogn) ,后面遍历length数组所花费的时间复杂度为 O(n) ,因此,本方案的时间复杂度为 O(nlogn)