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