算法面试题之字符串子串

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