五一一眨眼就過去了，感覺還沒開始就結(jié)束了，哈哈。繼續(xù)刷題。

最長的斐波那契子序列的長度

題目：如果序列 X_1, X_2, ..., X_n 滿足下列條件，就說它是 斐波那契式 的：n >= 3

對(duì)于所有 i + 2 <= n，都有 X_i + X_{i+1} = X_{i+2}

給定一個(gè)嚴(yán)格遞增的正整數(shù)數(shù)組形成序列，找到 A 中最長的斐波那契式的子序列的長度。如果一個(gè)不存在，返回 0 。（回想一下，子序列是從原序列 A 中派生出來的，它從 A 中刪掉任意數(shù)量的元素（也可以不刪），而不改變其余元素的順序。例如， [3, 5, 8] 是 [3, 4, 5, 6, 7, 8] 的一個(gè)子序列）

示例 1：
輸入: [1,2,3,4,5,6,7,8]
輸出: 5
解釋:
最長的斐波那契式子序列為：[1,2,3,5,8] 。
示例 2：
輸入: [1,3,7,11,12,14,18]
輸出: 3
解釋:
最長的斐波那契式子序列有：
[1,11,12]，[3,11,14] 以及 [7,11,18] 。
提示：
3 <= A.length <= 1000
1 <= A[0] < A[1] < ... < A[A.length - 1] <= 10^9
（對(duì)于以 Java，C，C++，以及 C# 的提交，時(shí)間限制被減少了 50%）

思路：這個(gè)題就簡單的很了。找出每一個(gè)元素的當(dāng)前長度。比較直觀的一個(gè)dp就可以解決。雙層for循環(huán)。外層全部，內(nèi)層是外層前面的元素。找出每個(gè)元素當(dāng)前可湊成的最大子序列長度。因?yàn)檫@個(gè)題返回的也不用序列而是長度大大的減少了難度，我去實(shí)現(xiàn)了。
第一版實(shí)現(xiàn)代碼：

class Solution {
    public int lenLongestFibSubseq(int[] arr) {
        List<Integer> list = new ArrayList<>();
        Set<Integer> set = new HashSet<Integer>();
        for(int i : arr) set.add(i);
        int ans = 0;
        for(int i = 0;i<arr.length;i++){
            for(int j = i+1;j<arr.length;j++){
                int f = arr[i];
                int s = arr[j];
                int cur = 2;
                while(set.contains(f+s)){
                    cur++;
                    int t = f;
                    f = s;
                    s = t+s;                    
                }
                ans = Math.max(ans,cur);
            }
        }
        return ans>2?ans:0;
    }
}

本來想到挺好的dp。但是發(fā)現(xiàn)實(shí)現(xiàn)起來有點(diǎn)問題。因?yàn)殪巢瞧鯏?shù)列不僅僅與上一個(gè)數(shù)有關(guān)系，與上上一個(gè)也有關(guān)系。所以上面的思路全都不太對(duì)！當(dāng)然了我覺得dp肯定是能實(shí)現(xiàn)的。不過最后寫著寫著變成了暴力法，然后沒超時(shí)我都覺得挺驚喜的，哈哈 。不多說了，我去直接看看題解了：
附上一個(gè)很好理解的代碼：

class Solution {

    /**
     * dp[i][j] 以i，j為最后兩個(gè)數(shù)的數(shù)列長度
     * 遍歷求j結(jié)尾的各個(gè)數(shù)列長度
     * 因?yàn)閿?shù)組嚴(yán)格遞增
     * 雙指針求j前面和位j的組合
     *
     * time complexity : N^2
     * space complexity : N^2
     *
     * @param arr
     * @return
     */
    public int lenLongestFibSubseq(int[] arr) {
        int length = arr.length;

        int[][] dp = new int[length][length];
        int result = 0;

        for (int i = 2; i < length; i++) {
            int target = arr[i];
            int left = 0;
            int right = i - 1;

            while (left < right) {
                if (arr[left] + arr[right] < target) {
                    left++;
                } else if (arr[left] + arr[right] > target) {
                    right--;
                } else {
                    dp[right][i] = dp[left][right] + 1;
                    result = Integer.max(result,dp[right][i]);
                    left++;
                }
            }
        }
        return result > 0 ? result + 2 : 0;
    }

}

一個(gè)二維數(shù)據(jù)來表示狀態(tài)。然后用二分法來找出兩數(shù)和存不存在，存在則長度+1.而保證所求結(jié)果正確的前提的因?yàn)閿?shù)組是嚴(yán)格遞增的。我們可以保證得到的結(jié)果就是可能的最大值。這個(gè)寫法和我一開始的思路類似，只不過我自己沒寫出來，主要是暴力法過了就沒動(dòng)力寫了，哈哈。下一題下一題。

愛吃香蕉的珂珂

題目：珂珂喜歡吃香蕉。這里有 N 堆香蕉，第 i 堆中有 piles[i] 根香蕉。警衛(wèi)已經(jīng)離開了，將在 H 小時(shí)后回來。珂珂可以決定她吃香蕉的速度 K （單位：根/小時(shí)）。每個(gè)小時(shí)，她將會(huì)選擇一堆香蕉，從中吃掉 K 根。如果這堆香蕉少于 K 根，她將吃掉這堆的所有香蕉，然后這一小時(shí)內(nèi)不會(huì)再吃更多的香蕉。 珂珂喜歡慢慢吃，但仍然想在警衛(wèi)回來前吃掉所有的香蕉。返回她可以在 H 小時(shí)內(nèi)吃掉所有香蕉的最小速度 K（K 為整數(shù)）。

示例 1：
輸入: piles = [3,6,7,11], H = 8
輸出: 4
示例 2：
輸入: piles = [30,11,23,4,20], H = 5
輸出: 30
示例 3：
輸入: piles = [30,11,23,4,20], H = 6
輸出: 23
提示：
1 <= piles.length <= 10^4
piles.length <= H <= 10^9
1 <= piles[i] <= 10^9

思路：這個(gè)題我的想法就是首先第一步排序。其次h和總堆數(shù)的關(guān)系。如果遇到正好相等，那么則取最大堆數(shù)的值。否則的話，因?yàn)轭}目的標(biāo)簽是二分。我的想法是遞增。因?yàn)檫@個(gè)數(shù)據(jù)范圍很簡單：最小值就是這堆香蕉總數(shù)/h的值。最大值就是單堆最大值。然后二分去縮圈。最終確定最小值就行了。我去代碼實(shí)現(xiàn)下
第一版本代碼：

class Solution {
    public int minEatingSpeed(int[] piles, int h) {
        int max = -1;
        int min = -1;
        long sum = 0;
        for(int i :piles){
            max = Math.max(i,max);
            sum += i;
        }
        if(h == piles.length) return max;
        if(h>=sum) return 1;
        min =(int)(sum/h);
        while(max>min){
            int mid = (max-min)/2+min;
            if(isOk(mid,piles,h)){//當(dāng)前mid是可以滿足的。往小試試
                max = mid;
            }else{//當(dāng)前mid不滿足條件，所以往大試試
                min = mid+1;
            }
        }
        return  min;
    }
    public boolean isOk(int cur,int[] piles,int h){
        int d = 0;
        for(int i:piles){
            d += i/cur+(i%cur==0?0:1);
        }
        return d<=h;
    }
}

我發(fā)現(xiàn)，一個(gè)坑我可以不斷往里跳。這個(gè)代碼不難，我兩次錯(cuò)誤都是數(shù)據(jù)溢出。一開始sum我用的int，結(jié)果溢出了。結(jié)果錯(cuò)誤。然后把sum改完了直接提交發(fā)現(xiàn)min計(jì)算的時(shí)候long不能直接變成int，又報(bào)錯(cuò)了。但是總體上思路沒啥變化。性能一般，然后優(yōu)化的點(diǎn)暫時(shí)沒想到，感覺應(yīng)該是isOk中的判斷可以優(yōu)化，但是我沒啥思路。我去看看別人的代碼吧。

class Solution {
    public int minEatingSpeed(int[] piles, int h) {
        int max = 1000000000;
        int min = 1;
        while(max>min){
            int mid = (max-min)/2+min;
            if(isOk(mid,piles,h)){//當(dāng)前mid是可以滿足的。往小試試
                max = mid;
            }else{//當(dāng)前mid不滿足條件，所以往大試試
                min = mid+1;
            }
        }
        return  min;
    }
    public boolean isOk(int cur,int[] piles,int h){
        int d = 0;
        for(int i:piles){
            d += (i-1)/cur + 1;
        }
        return d<=h;
    }
}

我現(xiàn)在的直覺好準(zhǔn)?。。。」粌?yōu)化點(diǎn)就是在那個(gè)三目運(yùn)算。如上代碼只改了計(jì)算，就性能賊好了。（i-1）/cur +1.這個(gè)方式讓我們很好的實(shí)現(xiàn)了向上取余。然后項(xiàng)目立刻超過百分之九十八的人，總而言之這個(gè)題就這樣了，主要還是二分。下一題。

石子游戲

題目：亞歷克斯和李用幾堆石子在做游戲。偶數(shù)堆石子排成一行，每堆都有正整數(shù)顆石子 piles[i] 。游戲以誰手中的石子最多來決出勝負(fù)。石子的總數(shù)是奇數(shù)，所以沒有平局。亞歷克斯和李輪流進(jìn)行，亞歷克斯先開始。 每回合，玩家從行的開始或結(jié)束處取走整堆石頭。 這種情況一直持續(xù)到?jīng)]有更多的石子堆為止，此時(shí)手中石子最多的玩家獲勝。假設(shè)亞歷克斯和李都發(fā)揮出最佳水平，當(dāng)亞歷克斯贏得比賽時(shí)返回 true ，當(dāng)李贏得比賽時(shí)返回 false 。

示例：
輸入：[5,3,4,5]
輸出：true
解釋：
亞歷克斯先開始，只能拿前 5 顆或后 5 顆石子 。
假設(shè)他取了前 5 顆，這一行就變成了 [3,4,5] 。
如果李拿走前 3 顆，那么剩下的是 [4,5]，亞歷克斯拿走后 5 顆贏得 10 分。
如果李拿走后 5 顆，那么剩下的是 [3,4]，亞歷克斯拿走后 4 顆贏得 9 分。
這表明，取前 5 顆石子對(duì)亞歷克斯來說是一個(gè)勝利的舉動(dòng)，所以我們返回 true 。
提示：
2 <= piles.length <= 500
piles.length 是偶數(shù)。
1 <= piles[i] <= 500
sum(piles) 是奇數(shù)。

思路：典型的dp？因?yàn)槊看芜x擇只能選擇前后二者之一。如果到了某點(diǎn)：不管是選前還是選后都一定輸，那么這個(gè)人就輸了?；蛘邠Q個(gè)思路。當(dāng)一個(gè)人先拿到總數(shù)的一半以上，就是贏了。之前做過石子游戲4好像是差不多的思路，我去琢磨琢磨遞推公式。
第一版代碼:

class Solution {
    public boolean stoneGame(int[] piles) {
        int len = piles.length;
        int[][] dp = new int[len][len];
        for (int i = 0; i < len; i++) {
            dp[i][i] = piles[i];
        }
        for (int j = 1; j < len; j++) {
            for (int i = j - 1; i >= 0; i--) {
                dp[i][j] = Math.max(piles[i] - dp[i + 1][j], piles[j] - dp[i][j - 1]);
            }
        }
        return dp[0][len - 1] > 0;
    }
}

這個(gè)代碼怎么說呢，性能一言難盡，二維dp。其實(shí)這個(gè)理論就是一個(gè)博弈論的思路：不僅我要多拿，而且還得讓你少拿。這個(gè)才是精髓。所以每次取值是取當(dāng)前減去下一個(gè)（從頭拿就是第二個(gè)，從尾拿就是倒數(shù)第二個(gè)）的較大值。也就是拿了這個(gè)不僅是我拿的多，還有你的選擇少。然後為啥性能不咋地我也不知道，我去看看性能第一的代碼:
手動(dòng)滑稽，性能第一的代碼:

性能第一的代碼

怎么說呢，我看了題解，發(fā)現(xiàn)竟然挺有道理。因?yàn)楦鶕?jù)題目條件，先拿的人占了絕對(duì)優(yōu)勢！下面是官方講解:

假設(shè)有 nn 堆石子，nn 是偶數(shù)，則每堆石子的下標(biāo)從 0 到 n-1。根據(jù)下標(biāo)將 n堆石子分成兩組，每組有 n/2堆石子，下標(biāo)為偶數(shù)的石子堆屬于第一組，下標(biāo)為奇數(shù)的石子堆屬于第二組。
初始時(shí)，行的開始處的石子堆位于下標(biāo) 00，屬于第一組，行的結(jié)束處的石子堆位于下標(biāo) n-1n?1，屬于第二組，因此作為先手的 \text{Alex}Alex 可以自由選擇取走第一組的一堆石子或者第二組的一堆石子。如果 \text{Alex}Alex 取走第一組的一堆石子，則剩下的部分在行的開始處和結(jié)束處的石子堆都屬于第二組，因此 \text{Lee}Lee 只能取走第二組的一堆石子。如果 \text{Alex}Alex 取走第二組的一堆石子，則剩下的部分在行的開始處和結(jié)束處的石子堆都屬于第一組，因此 \text{Lee}Lee 只能取走第一組的一堆石子。無論 \text{Lee}Lee 取走的是開始處還是結(jié)束處的一堆石子，剩下的部分在行的開始處和結(jié)束處的石子堆一定是屬于不同組的，因此輪到 \text{Alex}Alex 取走石子時(shí)，\text{Alex}Alex 又可以在兩組石子之間進(jìn)行自由選擇。
根據(jù)上述分析可知，作為先手的 \text{Alex}Alex 可以在第一次取走石子時(shí)就決定取走哪一組的石子，并全程取走同一組的石子。既然如此，\text{Alex}Alex 是否有必勝策略？
答案是肯定的。將石子分成兩組之后，可以計(jì)算出每一組的石子數(shù)量，同時(shí)知道哪一組的石子數(shù)量更多。\text{Alex}Alex 只要選擇取走數(shù)量更多的一組石子即可。因此，\text{Alex}Alex 總是可以贏得比賽。

這個(gè)題是腦筋急轉(zhuǎn)彎吧，可惜我一開始完全想著dp，完全沒想明白這個(gè)。。下一題了。

完成所有工作的最短時(shí)間

題目：給你一個(gè)整數(shù)數(shù)組 jobs ，其中 jobs[i] 是完成第 i 項(xiàng)工作要花費(fèi)的時(shí)間。請(qǐng)你將這些工作分配給 k 位工人。所有工作都應(yīng)該分配給工人，且每項(xiàng)工作只能分配給一位工人。工人的 工作時(shí)間 是完成分配給他們的所有工作花費(fèi)時(shí)間的總和。請(qǐng)你設(shè)計(jì)一套最佳的工作分配方案，使工人的 最大工作時(shí)間 得以 最小化 。返回分配方案中盡可能 最小 的 最大工作時(shí)間 。

示例 1：
輸入：jobs = [3,2,3], k = 3
輸出：3
解釋：給每位工人分配一項(xiàng)工作，最大工作時(shí)間是 3 。
示例 2：
輸入：jobs = [1,2,4,7,8], k = 2
輸出：11
解釋：按下述方式分配工作：
1 號(hào)工人：1、2、8（工作時(shí)間 = 1 + 2 + 8 = 11）
2 號(hào)工人：4、7（工作時(shí)間 = 4 + 7 = 11）
最大工作時(shí)間是 11 。
提示：
1 <= k <= jobs.length <= 12
1 <= jobs[i] <= 107

思路：首先這個(gè)題的數(shù)據(jù)范圍好小。job的數(shù)量和k最大只能12。然后這個(gè)題我的理解是如何把數(shù)組分成k份，使得份數(shù)的最大和最小。說的比較繞，但是 我覺得還是能理解。然后就12個(gè)數(shù)據(jù)，我的想法是先排序，然后二分查找最合適的值。有點(diǎn)類似上面的題。我去試試代碼。
兩次ac，而且第一次沒過的原因是馬虎了寫錯(cuò)一個(gè)細(xì)節(jié)，簡直覺得自己行了，哈哈，貼上代碼：

class Solution {
    public int minimumTimeRequired(int[] jobs, int k) {
        Arrays.sort(jobs);
        int sum = 0;
        int max = 0;
        for(int i : jobs){
            sum += i;
            max = Math.max(i,max);
        }
        if(jobs.length == k) return max;
        if(k == 1) return sum;
        //二分查看最小和.這里sum是最大值，max是最小值。
        while (max<sum){
            int mid = (sum-max)/2+max;
            if(isOk(jobs,k,mid)){//說明mid為和是可以的，繼續(xù)往下縮圈
                sum = mid;
            }else{//mid為和太小，往大擴(kuò)
                max = mid+1;
            }
        }
        return  max;
    }
    public boolean isOk(int[] jobs,int k,int cur){
        int[] d = new int[k];//k個(gè)工人的工作量
        d[0] = jobs[jobs.length-1];//最大的元素先分配給第一個(gè)工人。
        //后面的每個(gè)元素都不一樣要分配給誰。而且這里有個(gè)概念：
        // 已經(jīng)有工作了再被分配涉及到組合問題， 所有組合都要試一遍。
        //但是如果沒有工作的一些人，不管是誰接手這個(gè)工作都是一樣的，所以不用都試一遍
        return dfs(jobs,d,cur,jobs.length-2);
    }
    public boolean dfs(int[] jobs,int[] d,int cur,int temp){
        if(temp<0) return true;//所有工作都做完了，并且不超過cur，所以true
        int time = jobs[temp];
        for(int i = 0;i<d.length;i++){
            if(d[i]+time<=cur){//說明可以給d[i]，遞歸往下試試
                d[i] += time;
                if(dfs(jobs,d,cur,temp-1)) return true;
                d[i] -= time;//回溯，當(dāng)前值給d[i]不正確。所以還原
            }
            //如果當(dāng)前工作量是0,說明沒分配活，那么后面也都沒分配。不用試了。另外當(dāng)前正好是最佳工作量如果還不行也沒必要試了
            if(d[i] == 0 || d[i] + time == cur) break;
        }
        return false;
    }
}

其實(shí)我注釋寫的挺清楚了。然后說一下思路變化：首先感謝上上一道題也是二分查找，所以這個(gè)題我最開始就計(jì)劃二分，這個(gè)主體思路是沒問題的。最大值是總和，就是這么多任務(wù)分給一個(gè)人。最小值是所有工作時(shí)間的最大值（因?yàn)閗小于等于長度，也就是每個(gè)工人最少做一個(gè)工作，所以最小長度就是給定的這工作的最大值）。但是重點(diǎn)這個(gè)題是怎么確定能不能將所有數(shù)據(jù)分成k份，每份最大和不大于給定值cur。
因?yàn)檫@里涉及到工作的組合，而且題目中標(biāo)簽就是回溯和遞歸，所以這個(gè)很容易能想到思路就是回溯。問題是怎么落實(shí)到實(shí)際呢？
首先我覺得從大時(shí)間往小時(shí)間插入是一個(gè)比較優(yōu)的解法。畢竟N個(gè)小數(shù)據(jù)先組合了，剩下大的都沒地方放肯定要做很多無用功，所以我這里所有的遍歷都是倒敘遍歷。其次還有一個(gè)優(yōu)化點(diǎn)我在注釋中寫的很明白了。當(dāng)所有工人都沒工作的時(shí)候，誰接了某一個(gè)活是無所謂的，大家都是從0開始，不涉及到組合什么的。另外就是當(dāng)前工人正好做到了給定值的工作時(shí)長。就一定是當(dāng)前人的最優(yōu)解了，因?yàn)槭菑拇蟮叫”闅v，也不存在耽誤別人什么的，總而言之這兩種情況都不用再往下判斷。
于是給出了上面的代碼。性能超過了百分之九十九，所以我就不打算看題解和性能第一的代碼了，哈哈。下一題下一題。

索引處的解碼字符串

題目：給定一個(gè)編碼字符串 S。請(qǐng)你找出 解碼字符串 并將其寫入磁帶。解碼時(shí)，從編碼字符串中 每次讀取一個(gè)字符 ，并采取以下步驟：如果所讀的字符是字母，則將該字母寫在磁帶上。如果所讀的字符是數(shù)字（例如 d），則整個(gè)當(dāng)前磁帶總共會(huì)被重復(fù)寫 d-1 次。現(xiàn)在，對(duì)于給定的編碼字符串 S 和索引 K，查找并返回解碼字符串中的第 K 個(gè)字母。

示例 1：
輸入：S = "leet2code3", K = 10
輸出："o"
解釋：
解碼后的字符串為 "leetleetcodeleetleetcodeleetleetcode"。
字符串中的第 10 個(gè)字母是 "o"。
示例 2：
輸入：S = "ha22", K = 5
輸出："h"
解釋：
解碼后的字符串為 "hahahaha"。第 5 個(gè)字母是 "h"。
示例 3：
輸入：S = "a2345678999999999999999", K = 1
輸出："a"
解釋：
解碼后的字符串為 "a" 重復(fù) 8301530446056247680 次。第 1 個(gè)字母是 "a"。
提示：
2 <= S.length <= 100
S 只包含小寫字母與數(shù)字 2 到 9 。
S 以字母開頭。
1 <= K <= 10^9
題目保證 K 小于或等于解碼字符串的長度。
解碼后的字符串保證少于 2^63 個(gè)字母。

思路：個(gè)人感覺這個(gè)題有點(diǎn)簡單的離譜啊。。首先絕對(duì)不可能把這個(gè)字符串都拼出來。畢竟2的63次方有點(diǎn)嚇人。。其次也沒啥必要。就比如示例3中，那么多數(shù)字倍數(shù)，但是要求的下標(biāo)1，第一個(gè)乘2就能獲取到了。而且注意這個(gè)K是小于等于10的九次方的，所以我的想法就是遇到數(shù)字每次數(shù)字計(jì)算都算一下當(dāng)前長度是不是包含k了，包含的話直接取k下標(biāo)的值。以后不要計(jì)算了。大概思路就是這樣，我去落實(shí)到代碼上。
怎么說呢，果不其然超內(nèi)存了。。然后敲之前的代碼的時(shí)候我就有想過能不能不把這個(gè)字符串打印出來，直接往上計(jì)算長度。然后逆推取模K。。我感覺這個(gè)思路沒問題，我去試試看：
勉強(qiáng)過了，附上代碼：

class Solution {
    public String decodeAtIndex(String S, int K) {
        long size = 0;
        int idx = -1;
        for(int i = 0;i<S.length();i++){
            if(Character.isLetter(S.charAt(i))){//字母當(dāng)前長度+1
                size++;
                //當(dāng)前長度夠用了
                if(size == K) return S.charAt(i)+"";
            }else {//數(shù)字是相乘
                size *= S.charAt(i)-'0';
                if(size>=K){
                    idx = i;
                    break;
                }
            }
        }
        //從idx往前遍歷就行了
        for(int i = idx;i>=0;i--){
            K %= size;
            if(K == 0 && Character.isLetter(S.charAt(i))) return S.charAt(i)+"";
            if(Character.isLetter(S.charAt(i))){
                size--;
            }else {
                size /= S.charAt(i)-'0';
            }
        }
        return null;
    }
}

性能就是低空略過。然后這個(gè)是分兩次計(jì)算：第一次計(jì)算到K的長度需要字符串解析到哪里（整個(gè)字符串解析完可能比K大的多，但是那些都沒必要管，我們只解析到k就可以了）。然后我們從這個(gè)字符開始往前逆推。改除的就除（之前乘來的），該減的減（之前加來的）。然后一定要找到K那個(gè)點(diǎn)。這里有兩個(gè)需要注意的：一個(gè)是如果size正好等于K，一開始我是直接返回這個(gè)對(duì)應(yīng)的i的元素，后來發(fā)現(xiàn)可能是數(shù)字，所以改了。
第二個(gè)也是差不多的問題，一開始我是K=0就返回那個(gè)i對(duì)應(yīng)的元素。同理可能是數(shù)字，所以又改了。
剩下別的就沒啥了。這個(gè)代碼3ms，只超過了百分之十九的人，我去看看性能第一的代碼：

class Solution {
    public String decodeAtIndex(String S, int K) {
        long size = 0;
        int N = S.length();

        // Find size = length of decoded string
        for (int i = 0; i < N; ++i) {
            char c = S.charAt(i);
            if (Character.isDigit(c))
                size *= c - '0';
            else
                size++;
        }

        for (int i = N-1; i >= 0; --i) {
            char c = S.charAt(i);
            K %= size;
            if (K == 0 && Character.isLetter(c))
                return Character.toString(c);

            if (Character.isDigit(c))
                size /= c - '0';
            else
                size--;
        }
        throw null;
    }
}

萬萬沒想到這個(gè)代碼居然是我的代碼的閹割版？？有點(diǎn)日了狗的心情。我當(dāng)時(shí)想著k以后的沒用就不要遍歷了。可能因此多出了許多的判斷？？反正是這個(gè)性能第一代碼比我寫的要簡單的多，而且性能也好。。是測試案例的問題吧。。。這個(gè)題就這樣了。
本篇筆記就記到這里，如果稍微幫到你了記得點(diǎn)個(gè)喜歡點(diǎn)個(gè)關(guān)注，也祝大家工作順順利利，生活健健康康！