算法面试题之字符串子串

“字符串子串”是网易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)